void sync_network::simulate_static(const unsigned int steps, const double time, const solve_type solver, const bool collect_dynamic, sync_dynamic & output_dynamic) {
output_dynamic.clear();
const double step = time / (double) steps;
const double int_step = step / 10.0;
store_dynamic(0.0, collect_dynamic, output_dynamic); /* store initial state */
for (double cur_time = step; cur_time < (time + step); cur_time += step) {
calculate_phases(solver, cur_time, step, int_step);
store_dynamic(cur_time, collect_dynamic, output_dynamic); /* store initial state */
}
}
void pcnn::simulate(const unsigned int steps, const pcnn_stimulus & stimulus, pcnn_dynamic & output_dynamic) {
output_dynamic.resize(steps, size());
for (unsigned int i = 0; i < steps; i++) {
calculate_states(stimulus);
store_dynamic(i, output_dynamic);
}
}
void legion_network::simulate(const unsigned int steps,
const double time,
const solve_type solver,
const bool collect_dynamic,
const legion_stimulus & stimulus,
legion_dynamic & output_dynamic) {
output_dynamic.clear();
m_stimulus = (legion_stimulus *) &stimulus;
create_dynamic_connections(stimulus);
const double step = time / (double) steps;
const double int_step = step / 10.0;
store_dynamic(0.0, collect_dynamic, output_dynamic); /* store initial state */
for (double cur_time = step; cur_time < time; cur_time += step) {
calculate_states(stimulus, solver, cur_time, step, int_step);
store_dynamic(cur_time, collect_dynamic, output_dynamic); /* store initial state */
}
}
void sync_network::simulate_dynamic(const double order, const double step, const solve_type solver, const bool collect_dynamic, sync_dynamic & output_dynamic) {
output_dynamic.clear();
double previous_order = 0.0;
double current_order = sync_local_order();
double integration_step = step / 10;
store_dynamic(0, collect_dynamic, output_dynamic); /* store initial state */
for (double time_counter = step; current_order < order; time_counter += step) {
calculate_phases(solver, time_counter, step, integration_step);
store_dynamic(time_counter, collect_dynamic, output_dynamic);
previous_order = current_order;
current_order = sync_local_order();
if (std::abs(current_order - previous_order) < 0.000001) {
// std::cout << "Warning: sync_network::simulate_dynamic - simulation is aborted due to low level of convergence rate (order = " << current_order << ")." << std::endl;
break;
}
}
}
