mrgsolv.h

Go to the documentation of this file.

// Copyright (C) 2013 - 2026  Metrum Research Group
//
// This file is part of mrgsolve.
//
// mrgsolve is free software: you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 2 of the License, or
// (at your option) any later version.
//
// mrgsolve is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with mrgsolve.  If not, see <http://www.gnu.org/licenses/>.

 
#ifndef MRGSOLV_H
#define MRGSOLV_H
 
#include <vector>
#include <iostream>
 
typedef void (*refun)(void*);
 
namespace mrgsolve {
struct resim {
  resim(refun x, void* y) : fun(x), prob(y){}
  resim(){}
  void operator()() {
    return fun(prob);
  }
  
protected: 
  refun fun; 
  void* prob; 
}; 
 
struct evdata {
  evdata(double a_, int b_) : time(a_), evid(b_) {
    cmt = 1;
    amt = 0.0;
    rate = 0.0;
    ii = 0.0;
    ss = 0; 
    addl = 0;
    now = false;
    check_unique = false;
  } 
  double time; 
  int evid;
  int cmt;
  double amt; 
  double rate;
  double ii; 
  int ss; 
  int addl;
  bool now;
  bool check_unique;
}; 
 
// Some functions for reporting values during a
// simulation run
template <class type> void report(type a) {
  std::cout << "from report " << a << std::endl;
}
template <class type1, class type2> void report(type1 a, type2 b) {
  std::cout << a << " " << b << std::endl;
}
 
}
namespace mrg = mrgsolve;

 

class databox {
public: 
  std::vector<double> ETA; 
  std::vector<double> EPS; 
  std::vector<double> SIGMA; 
  unsigned int newind; 
  double time; 
  int evid;  
  unsigned short int SYSTEMOFF; 
  double id;  
  double amt; 
  short int cmt; 
  int nid; 
  int idn; 
  int nrow; 
  int rown; 
  int irown; 
  int inrow; 
  bool CFONSTOP; 
  void* envir; 
  void stop() {SYSTEMOFF=9;}
  void stop_id() {SYSTEMOFF=2;}
  void stop_id_cf(){SYSTEMOFF=1;}
  std::vector<mrgsolve::evdata> mevector;
  void mevent(double time_, int evid_);
  void push(mrgsolve::evdata x);
  double mtime(double time_);
  double tad();
}; 

typedef std::vector<double> dvec;

#define MRGSOLVE_INIT_SIGNATURE \
  dvec& _A_0_, \
  const dvec& _A_, \
  const dvec& _THETA_, \
  dvec& _F_, \
  dvec& _ALAG_, \
  dvec& _R_, \
  dvec& _D_, \
  databox& self, \
  dvec& _pred_, \
  mrgsolve::resim& simeta
#define MRGSOLVE_INIT_SIGNATURE_N 10

#define MRGSOLVE_TABLE_SIGNATURE \
  const dvec& _A_0_, \
  const dvec& _A_, \
  dvec& _THETA_, \
  const dvec& _F_, \
  const dvec& _ALAG_, \
  const dvec& _R_, \
  const dvec& _D_, \
  databox& self, \
  const dvec& _pred_, \
  dvec& _capture_, \
  mrgsolve::resim& simeta, \
  mrgsolve::resim& simeps
#define MRGSOLVE_TABLE_SIGNATURE_N 11

#define MRGSOLVE_EVENT_SIGNATURE MRGSOLVE_TABLE_SIGNATURE
#define MRGSOLVE_EVENT_SIGNATURE_N MRGSOLVE_TABLE_SIGNATURE_N

#define MRGSOLVE_ODE_SIGNATURE \
  const double* _ODETIME_, \
  const double* _A_, \
  double* _DADT_, \
  const dvec& _A_0_, \
  const dvec& _THETA_, \
  const bool _ss_flag_
#define MRGSOLVE_ODE_SIGNATURE_N 6

#define MRGSOLVE_CONFIG_SIGNATURE \
  databox& self, \
  const dvec& _THETA_, \
  const double neq, \
  const double npar, \
  bool& _check_modeled_infusions
#define MRGSOLVE_CONFIG_SIGNATURE_N 5
 
#endif