void evolve_network(network *net) {
FILE *fh, *fhtime;
char msg[1024], outdir[1024], msg2[80];
double dx = 1000./(net->npcent);
double dt = dx/(net->c); // physical time-step (seconds)
int n_steps = round((net->tmax)/dt);
//int n_steps = 4;
int n_skip = net->nskip;
//int n_skip = 1;
int n_curr = 0;
printf("Simulating network for %f hours\nTime step is %f (in secs)\nTotal steps %d\n", (net->tmax)/3600., dt, n_steps);
init_dump(net);
while (1) {
#if NOISE
split_step2(net, dx, n_curr*dt); // note (dx = dtau)
//printf("Uncomment to run with noise\n"); exit(1);
#else
memcpy(p_prev, net->link[0]->p, (net->link[0]->N)*sizeof(double));
split_step2nonoise(net, dx, n_curr*dt); // note (dx = dtau)
#endif
if (ADIABATIC) adiabatic_rk4(net->link[0]->fx, dt);
n_curr++;
if (n_curr % n_skip == 0) {
printf("t = %.8e min\n", n_curr*dt/60.);
dump_current(net, n_curr*dt);
save_adiabatic();
if (ADIABATIC_SAVE) save_adiabatic_temporal();
if (PIPE_SAVE) {
for (int n = 0; n < net->nlinks; n++){
sprintf(msg, "%s/pipe_%03d/%s_%03d.txt", net->current_dir, n, net->dname, n_curr/n_skip);
fh = fopen(msg, "w");
save_data(fh, net->link[n], net, n_curr*dt);
fclose(fh);
}
/*if (net->mglf != 0) {
sprintf(outdir, "%s/network", net->current_dir);
sprintf(msg, "%s/%s_%03d.png", outdir, net->dname, n_curr/n_skip);
sprintf(msg2, "t = %.3f sec", n_curr*dt);
mgl_draw_network(net, msg, msg2);
}*/
}
}
if (n_curr == n_steps) break;
}
printf("t = %.8e min\n", n_curr*dt/60.);
fhtime = fopen("params.txt", "a");
fprintf(fhtime, "%e\t%e\t%e\n", n_curr*dt/3600., ((net->knot[1])->P)*0.000001, ovsq2*((net->link[0])->W_l - (net->link[0])->Wb_l)/(net->c) );
fclose(fhtime);
}
int main(int argc, char **argv)
{
char buf[1024];
int set_b = 0;
char *log_path, *loc_start_file;
const char *env_str;
DMALLOC_PNT addr;
unsigned long inter, limit_val, loc_start_size, loc_start_iter;
long addr_count;
int lock_on;
int loc_start_line;
unsigned int flags;
argv_help_string = "Sets dmalloc library env variables. Also try --usage.";
argv_version_string = dmalloc_version;
argv_process(args, argc, argv);
if (help_b) {
header();
(void)fprintf(stderr,
" For a list of the command-line options enter: %s --usage\n",
argv_argv[0]);
exit(0);
}
if (usage_b) {
header();
argv_usage(args, ARGV_USAGE_ALL);
exit(0);
}
if (very_verbose_b) {
verbose_b = 1;
}
/* try to figure out the shell we are using */
if ((! bourne_b) && (! cshell_b) && (! gdb_b) && (! rcshell_b)) {
choose_shell();
}
/* get the current debug information from the env variable */
env_str = getenv(OPTIONS_ENVIRON);
if (env_str == NULL) {
env_str = "";
}
_dmalloc_environ_process(env_str, &addr, &addr_count, &flags, &inter,
&lock_on, &log_path, &loc_start_file,
&loc_start_line, &loc_start_iter, &loc_start_size,
&limit_val);
/*
* So, if a tag was specified on the command line then we set the
* debug from it. If it was not then we see if the debug flags were
* set as a hex value from the -d. If this was not used then take
* the current value.
*/
if (tag == NULL) {
if (argv_was_used(args, DEBUG_ARG)) {
set_b = 1;
/* should we clear the rest? */
if (remove_auto_b && (! keep_b)) {
clear_b = 1;
}
}
else {
debug = flags;
}
}
else {
if (argv_was_used(args, DEBUG_ARG)) {
(void)fprintf(stderr, "%s: warning -d ignored, processing tag '%s'\n",
argv_program, tag);
}
set_b = 1;
debug = find_tag(0L, tag, NULL, 0);
/* should we clear the rest? */
if (remove_auto_b && (! keep_b)) {
clear_b = 1;
}
}
if (plus.aa_entry_n > 0) {
int plus_c;
for (plus_c = 0; plus_c < plus.aa_entry_n; plus_c++) {
BIT_SET(debug, token_to_value(ARGV_ARRAY_ENTRY(plus, char *, plus_c)));
set_b = 1;
}
}
if (minus.aa_entry_n > 0) {
int minus_c;
for (minus_c = 0; minus_c < minus.aa_entry_n; minus_c++) {
BIT_CLEAR(debug,
token_to_value(ARGV_ARRAY_ENTRY(minus, char *, minus_c)));
set_b = 1;
}
}
if (address != NULL) {
_dmalloc_address_break(address, &addr, &addr_count);
set_b = 1;
}
else if (clear_b) {
addr = NULL;
}
if (argv_was_used(args, INTERVAL_ARG)) {
inter = interval;
set_b = 1;
}
else if (clear_b) {
inter = 0;
}
/*
* NOTE: this should be after the debug setting which this tests.
*/
if (argv_was_used(args, THREAD_LOCK_ON_ARG)) {
lock_on = thread_lock_on;
set_b = 1;
}
else if (clear_b) {
lock_on = 0;
}
if (logpath != NULL) {
log_path = logpath;
set_b = 1;
}
else if (clear_b) {
log_path = NULL;
}
if (start_file != NULL) {
_dmalloc_start_break(start_file, &loc_start_file, &loc_start_line,
&loc_start_iter, &loc_start_size);
set_b = 1;
}
else if (start_iter > 0) {
loc_start_file = NULL;
loc_start_line = 0;
loc_start_iter = start_iter;
loc_start_size = 0;
set_b = 1;
}
else if (start_size > 0) {
loc_start_file = NULL;
loc_start_line = 0;
loc_start_iter = 0;
loc_start_size = start_size;
set_b = 1;
}
else if (clear_b) {
loc_start_file = NULL;
loc_start_line = 0;
loc_start_iter = 0;
loc_start_size = 0;
}
if (argv_was_used(args, LIMIT_ARG)) {
limit_val = limit_arg;
set_b = 1;
}
if (errno_to_print > 0) {
(void)fprintf(stderr, "%s: dmalloc_errno value '%d' = \n",
argv_program, errno_to_print);
(void)fprintf(stderr, " '%s'\n", local_strerror(errno_to_print));
}
if (list_tags_b) {
list_tags();
}
if (debug_tokens_b) {
attr_t *attr_p;
unsigned int left = 0x7fffffff;
(void)fprintf(stderr, "Debug Tokens:\n");
for (attr_p = attributes; attr_p->at_string != NULL; attr_p++) {
/* skip any disabled tokens */
if (attr_p->at_value == 0 && strcmp(attr_p->at_string, "none") != 0) {
continue;
}
if (attr_p->at_value != 0 && (! BIT_IS_SET(left, attr_p->at_value))) {
/* skip any tokens we've seen before */
continue;
}
if (very_verbose_b) {
(void)fprintf(stderr, "%s -- %s (%#lx)\n",
attr_p->at_string, attr_p->at_desc, attr_p->at_value);
}
else if (verbose_b) {
(void)fprintf(stderr, "%s -- %s\n",
attr_p->at_string, attr_p->at_desc);
}
else {
(void)fprintf(stderr, "%s\n", attr_p->at_string);
}
BIT_CLEAR(left, attr_p->at_value);
}
}
if (clear_b || set_b) {
_dmalloc_environ_set(buf, sizeof(buf), long_tokens_b, addr, addr_count,
debug, inter, lock_on, log_path, loc_start_file,
loc_start_line, loc_start_iter, loc_start_size,
limit_val);
set_variable(OPTIONS_ENVIRON, buf);
}
else if (errno_to_print == 0
&& (! list_tags_b)
&& (! debug_tokens_b)) {
dump_current();
}
argv_cleanup(args);
exit(0);
}