static void print_param(parameter_node_t * param, int level) { if(!param) return; parameter_node_t * child; char fmt[64]; //cwmp_log_debug("name: %s, type: %s, level: %d\n", param->name, cwmp_get_type_string(param->type), level); int i=0; sprintf(fmt, "|%%-%ds%%s, get:%%p set:%%p refresh:%%p", level*4); cwmp_log_debug(fmt, "----", param->name, param->get, param->set, param->refresh); child = param->child; if(!child) return; print_param(child, level+1); parameter_node_t * next = child->next_sibling; while(next) { print_param(next, level+1); next = next->next_sibling; } }
void sequential_indicator_simulation_lvm( indicator_property_array_t & property, const sugarbox_grid_t & grid, const ik_params_t & params, int seed, const mean_t ** mean_data, progress_reporter_t & report, bool use_corellogram, const unsigned char * mask) { print_algo_name("Sequential Indicator Simulation"); print_params(params); print_param("LVM", "on"); if(use_corellogram) { print_param("Corellogram", "on"); if (mask == NULL) do_sis(property, grid, params, seed, mean_data, report, corellogram_weight_calculator_t(), no_mask_t()); else do_sis(property, grid, params, seed, mean_data, report, corellogram_weight_calculator_t(), mask); } else { print_param("Corellogram", "off"); if (mask == NULL) do_sis(property, grid, params, seed, mean_data, report, sk_weight_calculator_t(), no_mask_t()); else do_sis(property, grid, params, seed, mean_data, report, sk_weight_calculator_t(), mask); } }
void print_params(const covariance_param_t & p) { print_param("Covariance type", p.m_covariance_type); print_param("Sill", p.m_sill); print_param("Nugget", p.m_nugget); print_param("Ranges", p.m_ranges); print_param("Angles", p.m_angles); }
void simple_cokriging_markI( const sugarbox_grid_t & grid, const cont_property_array_t & input_prop, const cont_property_array_t & secondary_data, mean_t primary_mean, mean_t secondary_mean, double secondary_variance, double correlation_coef, const neighbourhood_param_t & neighbourhood_params, const covariance_param_t & primary_cov_params, cont_property_array_t & output_prop) { if (input_prop.size() != output_prop.size()) throw hpgl_exception("simple_cokriging", boost::format("Input data size: %s. Output data size: %s. Must be equal.") % input_prop.size() % output_prop.size()); print_algo_name("Simple Colocated Cokriging Markov Model I"); print_params(neighbourhood_params); print_params(primary_cov_params); print_param("Primary mean", primary_mean); print_param("Secondary mean", secondary_mean); print_param("Secondary variance", secondary_variance); print_param("Correllation coef", correlation_coef); cov_model_t cov(primary_cov_params); cross_cov_model_mark_i_t<cov_model_t> cross_cov(correlation_coef, secondary_variance, &cov); int data_size = input_prop.size(); neighbour_lookup_t<sugarbox_grid_t, cov_model_t> n_lookup(&grid, &cov, neighbourhood_params); progress_reporter_t report(data_size); report.start(data_size); // for each node for (node_index_t i = 0; i < data_size; ++i) { // calc value cont_value_t result = -500; if (input_prop.is_informed(i)) { result = input_prop[i]; } else { cont_value_t secondary_value = secondary_data.is_informed(i) ? secondary_data[i] : secondary_mean; if (!calc_value(i, input_prop, secondary_value, primary_mean, secondary_mean, secondary_variance, cov, cross_cov, n_lookup, result)) { result = primary_mean + secondary_value - secondary_mean; } } // set value at node output_prop.set_at(i, result); report.next_lap(); } }
static void cmd_cfg(BaseSequentialStream *chp, int argc, char *argv[]) { const char* const command = (argc < 1) ? "" : argv[0]; if (!strcmp(command, "list")) { for (int i = 0;; i++) { const char* name = config_name_by_index(i); if (!name) break; const int res = print_param(name, true); if (res) { lowsyslog("Internal error %i\n", res); assert(0); } } } else if (!strcmp(command, "save") || !strcmp(command, "erase")) { if (motor_is_idle()) { const bool save = !strcmp(command, "save"); print_status((save ? config_save : config_erase)()); } else { puts("I'm sorry Dave, I'm afraid I can't do that"); } } else if (!strcmp(command, "get")) { if (argc < 2) { puts("Error: Not enough arguments"); return; } const int ret = print_param(argv[1], false); if (ret) print_status(ret); } else if (!strcmp(command, "set")) { if (argc < 3) { puts("Error: Not enough arguments"); return; } const char* const name = argv[1]; const float value = atoff(argv[2]); const int res = config_set(name, value); if (res == 0) print_param(name, false); print_status(res); } else { puts("Usage:\n" " cfg list\n" " cfg save\n" " cfg erase\n" " cfg get <name>\n" " cfg set <name> <value>"); } }
void print_params(const sgs_params_t & p) { print_param("Covariance type", p.m_covariance_type); print_param("Sill", p.m_sill); print_param("Nugget", p.m_nugget); print_param("Ranges", p.m_ranges); print_param("Angles", p.m_angles); print_param("Search radiuses", p.m_radiuses); print_param("Max number of neighbours", p.m_max_neighbours); if (p.m_calculate_mean) print_param("Mean", "automatic"); else print_param("Mean", p.mean()); print_param("Seed", p.m_seed); }
int main (int argc, char *argv[]) { int i; int ret; int failed = 0; OilParameter param; //xmlfile = "proto3"; std_log(LOG_FILENAME_LINE, "Test Started testsuite_proto3"); for(i=0;good_params[i];i++){ ret = oil_param_from_string (¶m, good_params[i]); if (!ret) { printf("***ERROR***\n"); std_log(LOG_FILENAME_LINE, "***ERROR***"); failed = 1; } print_param (¶m); } for(i=0;bad_params[i];i++){ ret = oil_param_from_string (¶m, bad_params[i]); if (ret) { printf("***ERROR***\n"); std_log(LOG_FILENAME_LINE, "***ERROR***"); failed = 1; } } std_log(LOG_FILENAME_LINE, "Test Successful"); create_xml(0); return failed; }
int cgi_page_txt(ExHttp *pHttp) { printf("\n--txt.cgi--\n"); print_param(pHttp); ex_send_file(pHttp, "hello.txt"); return 0; }
void print_parameters(double pb[]) { cout << "CMAS 2.0" << endl; print_param(pb,NPopulations,1); print_param(pb,MaxGenerations,1); print_param(pb,PopSizeM,1); print_param(pb,PopSizeSD,0); print_param(pb,ReproRateM,1); print_param(pb,ReproRateSD,0); print_param(pb,FemaleP,1); print_param(pb,MaleP,1); print_param(pb,JackP,1); cout << endl << endl; }
/* * Print linked list of parameters, just for debugging */ void print_params(FILE* _o, param_t* _p) { param_t* ptr; ptr = _p; while(ptr) { print_param(_o, ptr); ptr = ptr->next; } }
void print_params(char *objectDn, SaImmAdminOperationParamsT_2 **params) { int ix = 0; printf("Object: %s\n", objectDn); printf("%-50s %-12s Value(s)\n", "Name", "Type"); printf("========================================================================\n"); while(params[ix]) { print_param(params[ix]); ++ix; } }
void print_params(const ok_params_t & p) { print_param("Covariance type", p.m_covariance_type); print_param("Sill", p.m_sill); print_param("Nugget", p.m_nugget); print_param("Ranges", p.m_ranges); print_param("Angles", p.m_angles); print_param("Search radiuses", p.m_radiuses); print_param("Max number of neighbours", p.m_max_neighbours); }
static void update_screen(struct mmi_ao *me) { lcd_clear(); lcd_write(0, 0, (char *) menu_cur->name, 0); switch (menu_cur->typ) { case MENU_TYP_PARAM: print_param(menu_cur->param); break; default: break; } }
void cwmp_agent_session(cwmp_t * cwmp) { char name[1024] = {0}; char value[1024]= {0}; char local_ip[32]; char * envstr; char * encstr; envstr = "SOAP-ENV"; //cwmp_conf_get("cwmp:soap_env"); encstr = "SOAP-ENC"; // cwmp_conf_get("cwmp:soap_enc"); cwmp_set_envelope_ns(envstr, encstr); if (cwmp_session_get_localip(local_ip) == -1) { cwmp_log_error("get local ip error. exited.\n"); exit(-1); } print_param(cwmp->root, 0); CWMP_SPRINTF_PARAMETER_NAME(name, 3, InternetGatewayDeviceModule, ManagementServerModule, URLModule); cwmp_data_set_parameter_value(cwmp, cwmp->root, name, cwmp->acs_url, TRstrlen(cwmp->acs_url), cwmp->pool); CWMP_SPRINTF_PARAMETER_NAME(name, 3, InternetGatewayDeviceModule, ManagementServerModule, ConnectionRequestURLModule); TRsnprintf(value, 1024, "http://%s:%d", local_ip, cwmp->httpd_port); cwmp_data_set_parameter_value(cwmp, cwmp->root, name, value, TRstrlen(value), cwmp->pool); CWMP_SPRINTF_PARAMETER_NAME(name, 3, InternetGatewayDeviceModule, DeviceInfoModule, ManufacturerModule); cwmp_data_set_parameter_value(cwmp, cwmp->root, name, cwmp->cpe_mf, TRstrlen(cwmp->cpe_mf), cwmp->pool); CWMP_SPRINTF_PARAMETER_NAME(name, 3, InternetGatewayDeviceModule, DeviceInfoModule, ManufacturerOUIModule); cwmp_data_set_parameter_value(cwmp, cwmp->root, name, cwmp->cpe_oui, TRstrlen(cwmp->cpe_oui), cwmp->pool); CWMP_SPRINTF_PARAMETER_NAME(name, 3, InternetGatewayDeviceModule, DeviceInfoModule, ProductClassModule); cwmp_data_set_parameter_value(cwmp, cwmp->root, name, cwmp->cpe_pc, TRstrlen(cwmp->cpe_pc), cwmp->pool); CWMP_SPRINTF_PARAMETER_NAME(name, 3, InternetGatewayDeviceModule, DeviceInfoModule, SerialNumberModule); cwmp_data_set_parameter_value(cwmp, cwmp->root, name, cwmp->cpe_sn, TRstrlen(cwmp->cpe_sn), cwmp->pool); cwmp_agent_start_session(cwmp); }
int cgi_page_sum(ExHttp *pHttp) { const char *lAdd, *rAdd; int sum; char buf[32]; printf("\n--add.cgi--\n"); print_param(pHttp); lAdd = get_param_info(pHttp, "lAdd"); rAdd = get_param_info(pHttp, "rAdd"); sum = atoi(lAdd) + atoi(rAdd); sprintf(buf, "%d", sum); ex_send_msg(pHttp, NULL, buf, strlen(buf)); return 0; }
int cgi_page_gallery(ExHttp *pHttp) { static int count = 0; char buf[40]; printf("\n--gallery.cgi--\n"); print_param(pHttp); count++; if (count > 3) { sprintf(buf, "All of pictures are shown. Reset"); count = 0; } else { sprintf(buf, "No. %d<br /><img src='%d.jpg' />", count, count); } ex_send_msg(pHttp, NULL, buf, strlen(buf)); return 0; }
int main(int argc, char *argv[]) { char ch; char pathname[256]; if (1 == argc) { print_usage(); return -1; } else { while (-1 != (ch = getopt(argc, argv, "c:hv"))) { switch (ch) { case 'c': snprintf(pathname, sizeof(pathname), "%s", optarg); break; case 'h': print_usage(); return 0; break; case 'v': fprintf(stderr, "%s\n", VERSION_INFO); return 0; break; default: return -1; break; } } } if (-1 == load_profile(pathname)) return -1; print_param(&g_confvalue); if (-1 == create_dir(g_confvalue.log_path, 0644)) return -1; snprintf(g_log_path, sizeof(g_log_path), "%s", g_confvalue.log_path); //process(); daemon_server(); return 0; }
int cgi_page_login(ExHttp *pHttp) { const char *smsg = "login success" ; const char *emsg = "login error" ; static const char *user = "******" ; static const char *passwd = "passwd" ; const char *pRet = emsg ; const char *pUser, *pPasswd ; printf( "\n--login.cgi--\n" ) ; print_param( pHttp ) ; pUser = get_param_info( pHttp, "user" ) ; pPasswd = get_param_info( pHttp, "passwd" ) ; if ( strcmp( user, pUser )==0&&strcmp( passwd, pPasswd )==0 ) { pRet = smsg ; } ex_send_msg( pHttp, NULL, pRet, strlen( pRet ) ) ; return 0 ; }
static int fractol_core(t_fol *f) { do_key(f); if (out_limits(f)) exit(0); f->step = 1 / f->zoom; f->def_min.x = -f->mid.x / f->zoom; f->def_min.y = -f->mid.y / f->zoom; f->def_max.x = (WIN_H - f->mid.x) / f->zoom; f->def_max.y = (WIN_W - f->mid.y) / f->zoom; print_rules(f); print_param(f); if (f->type == 'j') julia(f); else if (f->type == 'b') buddha(f); else if (f->type == 'B') buddha2(f); else mandelbrot(f); mlx_put_image_to_window(f->mlx, f->win, f->im, 0, 0); return (1); }
static void print_param_list(struct param_list *list, int depth) { struct param *p; struct keyword_param *k; int i; for (p = list->required_params, i = 0; p != NULL; p = p->next, i++) print_param(p, depth, "param", i); if (list->next_param) printf("%s#next %s\n", indent(depth), list->next_param->symbol->name); if (list->rest_param) printf("%s#rest %s\n", indent(depth), list->rest_param->symbol->name); if (list->allow_keys) { printf("%s#key\n", indent(depth)); for (k = list->keyword_params; k != NULL; k = k->next) { if (k->id->symbol != k->keyword) printf("%s%s: %s", indent(depth+1), k->keyword->name, k->id->symbol->name); else printf("%s%s:", indent(depth+1), k->keyword->name); if (k->type_temp) printf(" :: %s\n", k->type_temp->name); else if (k->type) { printf("\n%styped\n", indent(depth+2)); print_expr(k->type, depth+3); } else putchar('\n'); if (k->def) { printf("%sdefault\n", indent(depth+2)); print_expr(k->def, depth+3); } } if (list->all_keys) printf("%s#all-keys\n", indent(depth)); } }
int cgi_page_login(ExHttp *pHttp) { const char *smsg = "login success"; const char *emsg = "login error"; const char *gss = "get session success"; const char *ss = "send session"; //static const char *user = "******"; //static const char *passwd = "passwd"; const char *pRet = emsg; const char *pUser , *pPasswd, *pSession; printf("\n--login.cgi--\n"); print_param(pHttp); pSession = sessionFromHeader(get_head_info(pHttp, "Cookie")); pUser = get_param_info(pHttp, "user"); pPasswd = get_param_info(pHttp, "passwd"); /* if (strcmp(user, pUser) == 0 && strcmp(passwd, pPasswd) == 0) { pRet = smsg; } */ //ex_send_msg(pHttp, NULL, pRet, strlen(pRet)); void *data = sessionCheck(pSession); if(data != NULL){ ex_send_msg(pHttp, NULL, (char*)data, strlen((char*)data)); } else{ char *session_id = sessionCreate(pUser, "something"); pRet = ss; ex_send_msg_session(pHttp, NULL, pRet, strlen(pRet), session_id); } return 0; }
/* Function to be called from R */ void R_epidemics(int *seqLength, double *mutRate, int *npop, int *nHostPerPop, double *beta, int *nStart, int *t1, int *t2, int *Nsample, int *Tsample, int *duration, int *nbnb, int *listnb, double *pdisp){ int i, nstep, counter_sample = 0, tabidx; /* Initialize random number generator */ int j; time_t t; t = time(NULL); // time in seconds, used to change the seed of the random generator gsl_rng * rng; const gsl_rng_type *typ; gsl_rng_env_setup(); typ=gsl_rng_default; rng=gsl_rng_alloc(typ); gsl_rng_set(rng,t); // changes the seed of the random generator /* transfer simulation parameters */ struct param * par; par = (struct param *) malloc(sizeof(struct param)); par->L = *seqLength; par->mu = *mutRate; par->muL = par->mu * par->L; par->rng = rng; par->npop = *npop; par->popsizes = nHostPerPop; par->beta = *beta; par->nstart = *nStart; par->t1 = *t1; par->t2 = *t2; par->t_sample = Tsample; par->n_sample = *Nsample; par->duration = *duration; par->cn_nb_nb = nbnb; par->cn_list_nb = listnb; par->cn_weights = pdisp; /* check/print parameters */ check_param(par); print_param(par); /* dispersal matrix */ struct network *cn = create_network(par); /* print_network(cn, TRUE); */ /* group sizes */ struct ts_groupsizes * grpsizes = create_ts_groupsizes(par); /* initiate population */ struct metapopulation * metapop; metapop = create_metapopulation(par); /* get sampling schemes (timestep+effectives) */ translate_dates(par); struct table_int *tabdates = get_table_int(par->t_sample, par->n_sample); printf("\n\nsampling at timesteps:"); print_table_int(tabdates); /* create sample */ struct sample ** samplist = (struct sample **) malloc(tabdates->n * sizeof(struct sample *)); struct sample *samp; /* MAKE METAPOPULATION EVOLVE */ nstep = 0; while(get_total_nsus(metapop)>0 && (get_total_ninf(metapop)+get_total_nexp(metapop))>0 && nstep<par->duration){ nstep++; /* age metapopulation */ age_metapopulation(metapop, par); /* process infections */ for(j=0;j<get_npop(metapop);j++){ process_infections(get_populations(metapop)[j], metapop, cn, par); } /* draw samples */ if((tabidx = int_in_vec(nstep, tabdates->items, tabdates->n)) > -1){ /* TRUE if step must be sampled */ samplist[counter_sample++] = draw_sample(metapop, tabdates->times[tabidx], par); } fill_ts_groupsizes(grpsizes, metapop, nstep); } /* we stopped after 'nstep' steps */ if(nstep < par->duration){ printf("\nEpidemics ended at time %d, before last sampling time (%d).\n", nstep, par->duration); } else { /* printf("\n\n-- FINAL METAPOPULATION --"); */ /* print_metapopulation(metapop, FALSE); */ /* merge samples */ samp = merge_samples(samplist, tabdates->n, par); /* write sample to file */ printf("\n\nWriting sample to file 'out-sample.txt'\n"); write_sample(samp); /* free memory */ free_sample(samp); } /* write group sizes to file */ printf("\n\nPrinting group sizes to file 'out-popsize.txt'\n"); write_ts_groupsizes(grpsizes); /* free memory */ free_metapopulation(metapop); free_param(par); for(i=0;i<counter_sample;i++) free_sample(samplist[i]); free(samplist); free_table_int(tabdates); free_network(cn); free_ts_groupsizes(grpsizes); }
/** * Navigate state. * Navigates the menu structure using the following buttons: * - up => go to previous item * - down => go to next item * - left => go to parent item * - right => go to child item */ static QState mmi_navigate(struct mmi_ao *me) { switch (Q_SIG(me)) { case Q_ENTRY_SIG: update_screen(me); return Q_HANDLED(); case Q_EXIT_SIG: return Q_HANDLED(); case SIG_ENCODER: switch (menu_cur->typ) { case MENU_TYP_PARAM: if (modify_param(menu_cur->param, Q_PAR(me), me->shift)) { print_param(menu_cur->param); if (menu_cur->cmd != CMD_NONE) QActive_post((QActive *) me, SIG_MMI_CMD, menu_cur->cmd); } break; default: break; } return Q_HANDLED(); case SIG_MMI_CMD: return execute_cmd(me, Q_PAR(me)); case SIG_MMI_SHOW_MSG: return Q_TRAN(mmi_show_msg); case SIG_KEY_PRESS: switch (Q_PAR(me)) { case KEY_UP: // Go to previous item if (menu_prev()) update_screen(me); break; case KEY_DOWN: // Go to next item if (menu_next()) update_screen(me); break; case KEY_LEFT: // Go to parent item if (menu_parent()) update_screen(me); break; case KEY_RIGHT: // Go to sub item if (menu_sub()) update_screen(me); break; case KEY_ENTER: me->shift = 1; switch (menu_cur->typ) { case MENU_TYP_CMD: // Execute command if (menu_cur->cmd) QActive_post((QActive *) me, SIG_MMI_CMD, menu_cur->cmd); break; case MENU_TYP_SUB: // Go to sub item if (menu_sub()) update_screen(me); break; default: break; } break; } return Q_HANDLED(); case SIG_KEY_RELEASE: switch (Q_PAR(me)) { case KEY_ENTER: me->shift = 0; default: break; } return Q_HANDLED(); case SIG_PROG_START: return Q_TRAN(mmi_busy); break; } return Q_SUPER(&QHsm_top); }
void print_params(const neighbourhood_param_t & p) { print_param("Search radiuses", p.m_radiuses); print_param("Max number of neighbours", p.m_max_neighbours); }
int set_vsites(gmx_bool bVerbose, t_atoms *atoms, gpp_atomtype_t atype, t_params plist[]) { int i,j,ftype; int nvsite,nrbond,nrang,nridih,nrset; gmx_bool bFirst,bSet,bERROR; at2vsitebond_t *at2vb; t_mybonded *bonds; t_mybonded *angles; t_mybonded *idihs; bFirst = TRUE; bERROR = TRUE; nvsite=0; if (debug) fprintf(debug, "\nCalculating parameters for virtual sites\n"); /* Make a reverse list to avoid ninteractions^2 operations */ at2vb = make_at2vsitebond(atoms->nr,plist); for(ftype=0; (ftype<F_NRE); ftype++) if ((interaction_function[ftype].flags & IF_VSITE) && ftype != F_VSITEN) { nrset=0; nvsite+=plist[ftype].nr; for(i=0; (i<plist[ftype].nr); i++) { /* check if all parameters are set */ bSet=TRUE; for(j=0; j<NRFP(ftype) && bSet; j++) bSet = plist[ftype].param[i].c[j]!=NOTSET; if (debug) { fprintf(debug,"bSet=%s ",bool_names[bSet]); print_param(debug,ftype,i,&plist[ftype].param[i]); } if (!bSet) { if (bVerbose && bFirst) { fprintf(stderr,"Calculating parameters for virtual sites\n"); bFirst=FALSE; } nrbond=nrang=nridih=0; bonds = NULL; angles= NULL; idihs = NULL; nrset++; /* now set the vsite parameters: */ get_bondeds(NRAL(ftype), plist[ftype].param[i].a, at2vb, plist, &nrbond, &bonds, &nrang, &angles, &nridih, &idihs); if (debug) { fprintf(debug, "Found %d bonds, %d angles and %d idihs " "for virtual site %u (%s)\n",nrbond,nrang,nridih, plist[ftype].param[i].AI+1, interaction_function[ftype].longname); print_bad(debug, nrbond, bonds, nrang, angles, nridih, idihs); } /* debug */ switch(ftype) { case F_VSITE3: bERROR = calc_vsite3_param(atype, &(plist[ftype].param[i]), atoms, nrbond, bonds, nrang, angles); break; case F_VSITE3FD: bERROR = calc_vsite3fd_param(&(plist[ftype].param[i]), nrbond, bonds, nrang, angles); break; case F_VSITE3FAD: bERROR = calc_vsite3fad_param(&(plist[ftype].param[i]), nrbond, bonds, nrang, angles); break; case F_VSITE3OUT: bERROR = calc_vsite3out_param(atype, &(plist[ftype].param[i]), atoms, nrbond, bonds, nrang, angles); break; case F_VSITE4FD: bERROR = calc_vsite4fd_param(&(plist[ftype].param[i]), nrbond, bonds, nrang, angles); break; case F_VSITE4FDN: bERROR = calc_vsite4fdn_param(&(plist[ftype].param[i]), nrbond, bonds, nrang, angles); break; default: gmx_fatal(FARGS,"Automatic parameter generation not supported " "for %s atom %d", interaction_function[ftype].longname, plist[ftype].param[i].AI+1); } /* switch */ if (bERROR) gmx_fatal(FARGS,"Automatic parameter generation not supported " "for %s atom %d for this bonding configuration", interaction_function[ftype].longname, plist[ftype].param[i].AI+1); sfree(bonds); sfree(angles); sfree(idihs); } /* if bSet */ } /* for i */ if (debug && plist[ftype].nr) fprintf(stderr,"Calculated parameters for %d out of %d %s atoms\n", nrset,plist[ftype].nr,interaction_function[ftype].longname); } /* if IF_VSITE */ done_at2vsitebond(atoms->nr,at2vb); return nvsite; }
/* all-in-one function testing epidemics growth, summary statistics, etc. */ void test_epidemics(int seqLength, double mutRate, int npop, int *nHostPerPop, double beta, int nStart, int t1, int t2, int Nsample, int *Tsample, int duration, int *nbnb, int *listnb, double *pdisp){ int i, j, nstep=0, tabidx, counter_sample = 0; /* Initialize random number generator */ time_t t; t = time(NULL); // time in seconds, used to change the seed of the random generator gsl_rng * rng; const gsl_rng_type *typ; gsl_rng_env_setup(); typ=gsl_rng_default; rng=gsl_rng_alloc(typ); gsl_rng_set(rng,t); // changes the seed of the random generator /* transfer simulation parameters */ struct param * par; par = (struct param *) malloc(sizeof(struct param)); par->L = seqLength; par->mu = mutRate; par->muL = par->mu * par->L; par->rng = rng; par->npop = npop; par->npop = npop; par->popsizes = nHostPerPop; par->beta = beta; par->nstart = nStart; par->t1 = t1; par->t2 = t2; par->t_sample = Tsample; par->n_sample = Nsample; par->duration = duration; par->cn_nb_nb = nbnb; par->cn_list_nb = listnb; par->cn_weights = pdisp; /* check/print parameters */ check_param(par); print_param(par); /* dispersal matrix */ struct network *cn = create_network(par); /* group sizes */ struct ts_groupsizes * grpsizes = create_ts_groupsizes(par); /* initiate population */ struct metapopulation * metapop; metapop = create_metapopulation(par); /* get sampling schemes (timestep+effectives) */ translate_dates(par); struct table_int *tabdates = get_table_int(par->t_sample, par->n_sample); printf("\n\nsampling at timesteps:"); print_table_int(tabdates); /* create sample */ struct sample ** samplist = (struct sample **) malloc(tabdates->n * sizeof(struct sample *)); struct sample *samp; /* MAKE METAPOPULATION EVOLVE */ nstep = 0; while(get_total_nsus(metapop)>0 && (get_total_ninf(metapop)+get_total_nexp(metapop))>0 && nstep<par->duration){ nstep++; /* age metapopulation */ age_metapopulation(metapop, par); /* process infections */ for(j=0;j<get_npop(metapop);j++){ process_infections(get_populations(metapop)[j], metapop, cn, par); } /* draw samples */ if((tabidx = int_in_vec(nstep, tabdates->items, tabdates->n)) > -1){ /* TRUE if step must be sampled */ samplist[counter_sample++] = draw_sample(metapop, tabdates->times[tabidx], par); } fill_ts_groupsizes(grpsizes, metapop, nstep); } /* we stopped after 'nstep' steps */ if(nstep < par->duration){ printf("\nEpidemics ended at time %d, before last sampling time (%d).\n", nstep, par->duration); } else { printf("\n\n-- FINAL METAPOPULATION --"); print_metapopulation(metapop, TRUE); /* test samples */ for(i=0;i<tabdates->n;i++) { printf("\nsample %d\n", i); print_sample(samplist[i], TRUE); } samp = merge_samples(samplist, tabdates->n, par) ; print_sample(samp, TRUE); /* test allele listing */ struct snplist *snpbilan; snpbilan = list_snps(samp, par); print_snplist(snpbilan); /* test allele frequencies */ struct allfreq *freq; freq = get_frequencies(samp, par); print_allfreq(freq); /* test Hs*/ double Hs = hs(samp,par); printf("\nHs = %0.3f\n", Hs); /* test Hs full genome */ Hs = hs_full_genome(samp,par); printf("\nHs (full genome) = %0.5f\n", Hs); /* test nb of snps */ int nball = nb_snps(samp,par); printf("\nnumber of SNPs = %d\n", nball); /* test mean nb of snps */ double temp = mean_nb_snps(samp); printf("\nmean number of SNPs = %.2f\n", temp); /* test var nb of snps */ temp = var_nb_snps(samp); printf("\nvariance of number of alleles = %.2f\n", temp); /* test pairwise distances */ struct distmat_int *mat = pairwise_dist(samp, par); print_distmat_int(mat); /* test mean pairwise distances */ temp = mean_pairwise_dist(samp,par); printf("\nmean pairwise distance: %.2f", temp); /* test variance of pairwise distances */ temp = var_pairwise_dist(samp,par); printf("\nvar pairwise distance: %.2f", temp); /* test Fst */ temp = fst(samp,par); printf("\nfst: %.2f", temp); printf("\n\n"); /* free memory */ free_sample(samp); free_snplist(snpbilan); free_allfreq(freq); free_distmat_int(mat); } /* write group sizes to file */ printf("\n\nPrinting group sizes to file 'out-popsize.txt'"); write_ts_groupsizes(grpsizes); /* free memory */ free_metapopulation(metapop); free_param(par); for(i=0;i<counter_sample;i++) free_sample(samplist[i]); free(samplist); free_table_int(tabdates); free_network(cn); free_ts_groupsizes(grpsizes); }
/* Function to be called from R */ void R_monitor_epidemics(int *seqLength, double *mutRate, int *npop, int *nHostPerPop, double *beta, int *nStart, int *t1, int *t2, int *Nsample, int *Tsample, int *duration, int *nbnb, int *listnb, double *pdisp, int *minSize){ int nstep; /* Initialize random number generator */ int j; time_t t; t = time(NULL); // time in seconds, used to change the seed of the random generator gsl_rng * rng; const gsl_rng_type *typ; gsl_rng_env_setup(); typ=gsl_rng_default; rng=gsl_rng_alloc(typ); gsl_rng_set(rng,t); // changes the seed of the random generator /* transfer simulation parameters */ struct param * par; par = (struct param *) malloc(sizeof(struct param)); par->L = *seqLength; par->mu = *mutRate; par->muL = par->mu * par->L; par->rng = rng; par->npop = *npop; par->popsizes = nHostPerPop; par->beta = *beta; par->nstart = *nStart; par->t1 = *t1; par->t2 = *t2; par->t_sample = Tsample; par->n_sample = *Nsample; par->duration = *duration; par->cn_nb_nb = nbnb; par->cn_list_nb = listnb; par->cn_weights = pdisp; /* check/print parameters */ check_param(par); print_param(par); /* dispersal matrix */ struct network *cn = create_network(par); /* print_network(cn, TRUE); */ /* group sizes */ struct ts_groupsizes * grpsizes = create_ts_groupsizes(par); struct ts_sumstat * sumstats = create_ts_sumstat(par); /* initiate population */ struct metapopulation * metapop; metapop = create_metapopulation(par); /* get sampling schemes (timestep+effectives) */ translate_dates(par); struct table_int *tabdates = get_table_int(par->t_sample, par->n_sample); printf("\n\nsampling at timesteps:"); print_table_int(tabdates); /* create sample */ struct sample *samp; /* MAKE METAPOPULATION EVOLVE */ nstep = 0; while(get_total_nsus(metapop)>0 && (get_total_ninf(metapop)+get_total_nexp(metapop))>0 && nstep<par->duration){ nstep++; /* age metapopulation */ age_metapopulation(metapop, par); /* process infections */ for(j=0;j<get_npop(metapop);j++){ process_infections(get_populations(metapop)[j], metapop, cn, par); } /* draw sample */ samp = draw_sample(metapop, par->n_sample, par); /* compute statistics */ if(get_total_ninf(metapop)> *minSize) fill_ts_sumstat(sumstats, samp, nstep, par); /* get group sizes */ fill_ts_groupsizes(grpsizes, metapop, nstep); } /* write group sizes to file */ printf("\n\nWriting results to file..."); write_ts_groupsizes(grpsizes); write_ts_sumstat(sumstats); printf("done.\n\n"); /* free memory */ free_sample(samp); free_metapopulation(metapop); free_param(par); free_network(cn); free_ts_groupsizes(grpsizes); free_ts_sumstat(sumstats); }