void computeSystem(int myid, int nproc,char * dirIn,char * dirOut, char ** listFile, int numFile, int idxFile)
{
BioSystem sistema;
char * json_system;
//set input path file
char * fileNameIn = (char *) malloc(1000*sizeof(char));
char * fileNameOut = (char *) malloc(1000*sizeof(char));
strcpy( fileNameIn, dirIn);
strcat( fileNameIn, listFile[idxFile]);
//extract system from file
json_system = fget_contents(fileNameIn);
sistema = extract_from_json(json_system);
//set output path file
strcpy( fileNameOut,dirOut);
strcat( fileNameOut, sistema.name);
strcat( fileNameOut, ".out");
//algo submission
gillespie(sistema,fileNameOut);
}
void beetles(double* s1, double* s2, double* s3, double* s4, double* inits, int* n_samples, int* reps, double* maxtime)
{
/** Create a list of all event functions and their associated outcomes
* Order doesn't matter, but make sure outcomes are paired with the
* appropriate function! */
const size_t n_event_types = 8;
event_fn rate_fn[n_event_types];
event_fn outcome[n_event_types];
rate_fn[0] = &bE;
outcome[0] = &bE_out;
rate_fn[1] = &dE;
outcome[1] = &dE_out;
rate_fn[2] = &dL;
outcome[2] = &dL_out;
rate_fn[3] = &dP;
outcome[3] = &dP_out;
rate_fn[4] = &dA;
outcome[4] = &dA_out;
rate_fn[5] = &mE;
outcome[5] = &mE_out;
rate_fn[6] = &mL;
outcome[6] = &mL_out;
rate_fn[7] = &mP;
outcome[7] = &mP_out;
RESET reset_fn = &beetles_reset;
FIXED fixed_interval_fn = &beetles_fixed_interval;
record * my_record = b_record_alloc(*n_samples, *reps, *maxtime);
gillespie( rate_fn, outcome, n_event_types,
inits, my_record, *maxtime,
*reps, reset_fn, fixed_interval_fn);
int i;
for(i = 0; i< *n_samples * *reps; i++)
{
s1[i] = my_record->s1[i];
s2[i] = my_record->s2[i];
s3[i] = my_record->s3[i];
s4[i] = my_record->s4[i];
}
b_record_free(my_record);
}
int main(int argc, char *argv[])
{
/*no_mc == #MC ODEs; tstep = time step */
int i, j, no_mc = 27;
double tstep=1;
int par_index, sim_index;
gsl_matrix *pars_mat;
int prior = 0;
if(prior==1) {
pars_mat = readMatrix("../data/prior.csv");
} else {
pars_mat = readMatrix("../data/post.csv");
}
gsl_matrix *sim_mat = readMatrix("../data/sim.csv");
double *par_wts, *sim_wts;
par_wts = calloc(sizeof(double), pars_mat->size1);
sim_wts = calloc(sizeof(double), sim_mat->size1);
double *sps, *pars, *sps_gil;
sps = malloc(no_mc*sizeof(double));
sps_gil = malloc(6*sizeof(double));
/*Add in (fixed) k1 and k2 to pars*/
pars = malloc((pars_mat->size2+1)*sizeof(double));
/*total g & i*/
pars[pars_mat->size2-1] = 10; pars[pars_mat->size2] = 2;
gsl_ran_discrete_t *sim_sample, *par_sample;
gsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937);
gsl_rng_set (r, 1);
par_sample = gsl_ran_discrete_preproc(pars_mat->size1, (const double *) par_wts);
sim_sample = gsl_ran_discrete_preproc(sim_mat->size1, (const double *) sim_wts);
/* 1. Select parameters from post (select row)
2. Select time point of interest (select column)
3. Simulate from MC and Gillespie one time unit
4. Compare
5. Profit
*/
for(i=0; i<10000; i++) {
if(prior == 1) {
par_index = i;
} else {
par_index = gsl_ran_discrete(r, par_sample);
}
sim_index = gsl_ran_discrete(r, sim_sample);
/*Reset MC */
for(j=0; j<no_mc;j++) {
sps[j] = 0;
}
/* Sps order: rg, ri, g, i, G, I
column zero iteration number
*/
sps[0] = MGET(sim_mat, sim_index, 1);
sps[2] = MGET(sim_mat, sim_index, 2);
sps[5] = MGET(sim_mat, sim_index, 3);
sps[9] = MGET(sim_mat, sim_index, 4);
sps[14] = MGET(sim_mat, sim_index, 5);
sps[20] = MGET(sim_mat, sim_index, 6);
for(j=0; j<(pars_mat->size2-1); j++) {
pars[j] = MGET(pars_mat, par_index, j+1);
}
sps_gil[0] = sps[0]; sps_gil[1] = sps[2]; sps_gil[2] = sps[5];
sps_gil[3] = sps[9]; sps_gil[4] = sps[14]; sps_gil[5] = sps[20];
/* simulate from MC */
ode(pars, tstep, sps);
gillespie(sps_gil, pars, tstep, r);
printf("%f, %f, %f, %f, %f, %f, %d, %d\n",
(sps[0] - sps_gil[0])/(pow(sps[1], 0.5)),
(sps[2] - sps_gil[1])/(pow(sps[4], 0.5)),
(sps[5] - sps_gil[2])/(pow(sps[8], 0.5)),
(sps[9] - sps_gil[3])/(pow(sps[13], 0.5)),
(sps[14] - sps_gil[4])/(pow(sps[19], 0.5)),
(sps[20] - sps_gil[5])/(pow(sps[26], 0.5)),
par_index, sim_index
);
}
return(EXIT_SUCCESS);
}
void SSA (pomp_ssa_rate_fn *ratefun, int irep,
int nvar, int nevent, int npar, int nrep, int ntimes,
int method,
double *xstart, const double *times, const double *params, double *xout,
const double *e, const double *v, const double *d,
int ndeps, const int *ideps, int nzero, const int *izero,
const int *istate, const int *ipar, int ncovar, const int *icovar,
int lcov, int mcov, double *tcov, double *cov) {
int flag = 0;
double t = times[0];
double tmax = times[ntimes-1];
double *covars = NULL;
double *f = NULL;
double par[npar], y[nvar];
struct lookup_table tab = {lcov, mcov, 0, tcov, cov};
int i, j;
if (mcov > 0) covars = (double *) Calloc(mcov,double);
if (nevent > 0) f = (double *) Calloc(nevent,double);
// Copy parameters and states
for (i = 0; i < npar; i++) par[i] = params[i+npar*irep];
for (i = 0; i < nvar; i++)
xout[i+irep*nvar] = y[i] = xstart[i+nvar*irep];
// Set appropriate states to zero
for (i = 0; i < nzero; i++) y[izero[i]] = 0.0;
// Initialize the covariate vector
if (mcov > 0) table_lookup(&tab,t,covars);
// Initialise propensity functions & tree
for (j = 0; j < nevent; j++) {
f[j] = ratefun(j+1,t,y,par,istate,ipar,icovar,mcov,covars);
if (f[j] < 0.0)
errorcall(R_NilValue,"'rate.fun' returns a negative rate");
}
int icount = 1;
while (icount < ntimes) {
R_CheckUserInterrupt();
if (method == 0) { // Gillespie's next reaction method
flag = gillespie(ratefun,&t,f,y,v,d,par,nvar,nevent,npar,istate,ipar,ncovar,icovar,mcov,covars);
} else { // Cai's K-leap method
// Determine kappa (most accurate but slowest method)
double kappa, tmp;
int k;
for (i = 0, kappa = 1e9; i < ndeps; i++) {
k = ideps[i];
tmp = e[k]*y[k];
kappa = (tmp < kappa) ? tmp : kappa;
if (kappa < 2.0) break;
}
if (kappa < 2.0) {
flag = gillespie(ratefun,&t,f,y,v,d,par,nvar,nevent,npar,istate,ipar,ncovar,icovar,mcov,covars);
} else {
kappa = floor(kappa);
flag = kleap(ratefun,kappa,&t,f,y,v,d,par,nvar,nevent,npar,istate,ipar,ncovar,icovar,mcov,covars);
}
}
// Record output at required time points
while ((icount < ntimes) && (t >= times[icount])) {
for (i = 0; i < nvar; i++)
xout[i+nvar*(irep+nrep*icount)] = y[i];
// Set appropriate states to zero
for (i = 0; i < nzero; i++) y[izero[i]] =0.0;
// Recompute if zero event-rate encountered
if (flag) t = times[icount];
icount++;
}
if ((mcov > 0) && (t <= tmax)) table_lookup(&tab,t,covars);
}
if (mcov > 0) Free(covars);
if (nevent > 0) Free(f);
}
