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);
}
