void sync_network::calculate_phases(const solve_type solver, const double t, const double step, const double int_step) { std::vector<double> next_phases(size(), 0); std::vector<void *> argv(2, NULL); argv[0] = (void *) this; unsigned int number_int_steps = (unsigned int) (step / int_step); for (unsigned int index = 0; index < size(); index++) { argv[1] = (void *) &index; switch(solver) { case solve_type::FAST: { double result = m_oscillators[index].phase + phase_kuramoto(t, m_oscillators[index].phase, argv); next_phases[index] = phase_normalization(result); break; } case solve_type::RK4: { differ_state<double> inputs(1, m_oscillators[index].phase); differ_result<double> outputs; runge_kutta_4(m_callback_solver, inputs, t, t + step, number_int_steps, false, argv, outputs); next_phases[index] = phase_normalization( outputs[0].state[0] ); break; } case solve_type::RKF45: { differ_state<double> inputs(1, m_oscillators[index].phase); differ_result<double> outputs; runge_kutta_fehlberg_45(m_callback_solver, inputs, t, t + step, 0.00001, false, argv, outputs); next_phases[index] = phase_normalization( outputs[0].state[0] ); break; } default: { throw std::runtime_error("Unknown type of solver"); } } } /* store result */ for (unsigned int index = 0; index < size(); index++) { m_oscillators[index].phase = next_phases[index]; } }
void him::m_signal(int n, t_float *const *in, t_float *const *out) { t_float * out0 = out[0]; t_float * out1 = out[1]; t_float * out2 = out[2]; t_float * out3 = out[3]; t_float * out4 = out[4]; t_float * out5 = out[5]; if (regtime) { for (int i=0; i!=n; ++i) { runge_kutta_4(dt); (*(out0)++)=data[0]; (*(out1)++)=data[1]; (*(out2)++)=data[2]; (*(out3)++)=data[3]; (*(out4)++)=data[0]*data[2]; (*(out5)++)=(data[0]*data[0]-data[2]*data[2])*0.5; } } else { for (int i=0; i!=n; ++i) { runge_kutta_4(dt/(2*sqrt(data[0]*data[0]+data[2]*data[2]))); (*(out0)++)=data[0]; (*(out1)++)=data[1]; (*(out2)++)=data[2]; (*(out3)++)=data[3]; (*(out4)++)=data[0]*data[2]; (*(out5)++)=(data[0]*data[0]-data[2]*data[2])*0.5; } } if (xfade) { /* fading */ out0 = out[0]; out1 = out[1]; out2 = out[2]; out3 = out[3]; out4 = out[4]; out5 = out[5]; t_float * fader = m_fader + n - 1; for (int i=0; i!=n; ++i) { (*(out0)++) *= *fader; (*(out1)++) *= *fader; (*(out2)++) *= *fader; (*(out3)++) *= *fader; (*(out4)++) *= *fader; (*(out5)++) *= *fader--; } if (newsystem) { reset(); newsystem = false; } E = newE; dt = newdt; regtime = newregtime; out0 = out[0]; out1 = out[1]; out2 = out[2]; out3 = out[3]; out4 = out[4]; out5 = out[5]; fader = m_fader; if (regtime) { for (int i=0; i!=n; ++i) { runge_kutta_4(dt); (*(out0)++)+= data[0]* *fader; (*(out1)++)+= data[1]* *fader; (*(out2)++)+= data[2]* *fader; (*(out3)++)+= data[3]* *fader; (*(out4)++)+= data[0]*data[2]* *fader; (*(out5)++)+= (data[0]*data[0]-data[2]*data[2])*0.5* *fader++; } } else { for (int i=0; i!=n; ++i) { runge_kutta_4(dt/(2*sqrt(data[0]*data[0]+data[2]*data[2]))); (*(out0)++)+= data[0]* *fader; (*(out1)++)+= data[1]* *fader; (*(out2)++)+= data[2]* *fader; (*(out3)++)+= data[3]* *fader; (*(out4)++)+= data[0]*data[2]* *fader; (*(out5)++)+= (data[0]*data[0]-data[2]*data[2])*0.5* *fader++; } } xfade = false; } }
int main() { printf("Welcome to Chiu Industries. Pendulum Calculator. NO Driving Force Mode. \n"); FILE *output_file; //declarations of variables int number_of_steps; double initial_x, initial_v, final_t, E_initial; double h; double y[2], dydt[2], yout[2]; double t; double gamma; double period_initial = 10.0; int printInterval = 1; int printCounter = 0; double count; initial_v = -0.1; //output_file = fopen("finalq1a_rk4_vinitial_0pt1_gamma_neg0pt1_v1.dat", "w"); output_file = fopen("dragonfly.dat", "w"); //for(gamma=-10; gamma<11; gamma++) gamma = -0.1; for(count = -10; count<10; count++) { //fprintf(output_file, "#%12.10E \n", gamma); final_t = period_initial*10.0; h = 0.05; number_of_steps = final_t/h; initial_x = 0.0; //initial_v = 0.1; assert(number_of_steps >0); //initialise position and velocity y[0] = initial_x; y[1] = initial_v; E_initial = 0.5*y[0]*y[0] + 0.5*y[1]*y[1]; t=0.0; //output(output_file, h, t, y, E_initial, initial_v); while(t<=final_t) { derivatives(t,y,dydt, gamma); //euler(y, dydt, 2, t, h, yout); runge_kutta_4(y, dydt, 2, t, h, yout, derivatives); y[0]=yout[0]; y[1]=yout[1]; if(printCounter == printInterval) { output(output_file, h, t, y, E_initial, initial_v); printCounter = 0; } else{} printCounter++; t+=h; } initial_v = initial_v+0.01; } fclose(output_file); return 0; } //end main program
int main(void) { /***READ SCALE FACTOR DATA AND PREPARE OBJECTS FOR INTERPOLATION ***/ int i; //For array manipulation /*Pointer to scale_factor.data file*/ FILE *frw; frw = fopen("scale_factor.dat","r"); /*Variables and arrays to read the data*/ double cosmictime[NLINESFRW], conftime, scale_factor[NLINESFRW], der_scale_factor[NLINESFRW]; /*Reading the data*/ for(i=0; i<NLINESFRW; i++) { fscanf(frw,"%lf %lf %lf %lf", &cosmictime[i], &conftime, &scale_factor[i], &der_scale_factor[i]); } /*Free space in memory*/ fclose(frw); /*** Initializes objects for interpolation. 1 is for interpolation of scale factor, 2 is for interpolation of derivative of scale factor ***/ /*Allocate space in memory*/ gsl_interp_accel *acc1 = gsl_interp_accel_alloc(); //Acceleration type object (for index lookup) gsl_interp_accel *acc2 = gsl_interp_accel_alloc(); gsl_spline *spline1 = gsl_spline_alloc(gsl_interp_cspline, NLINESFRW); //Spline type object (define interpolation type and space in memory, works for both) gsl_spline *spline2 = gsl_spline_alloc(gsl_interp_cspline, NLINESFRW); /*Initializes objects for interpolation*/ gsl_spline_init(spline1, cosmictime, scale_factor, NLINESFRW); //Initializes spline object for data cosmictime, scale_factor of size NLINES gsl_spline_init(spline2, cosmictime, der_scale_factor, NLINESFRW); //Initializes spline object for data cosmictime, der_scale_factor of size NLINES /************************************************************************************/ /***SOLVES GEODESIC EQUATIONS FOR PERTURBED FRW UNIVERSE WITH STATIC PLUMMER POTENTIAL ***/ /*Initial conditions*/ mydbl ti = 7.0 ,x0, r = -500.0, p0 = 1.0e-3, pr, lambda = 0.0, energy1, energy, v, difft, difference; double difftfrw, aem, aobs; x0 = C*ti; aem = interpolator(spline1, (double)(1.0*ti), acc1); pr = condition_factor(r, aem)*p0; energy1 = C*energy_factor(r)*p0; v = violation(r, p0, pr, aem); difft = (energy1 - energy1)/energy1; difftfrw = (aem/aem) - 1.0; difference = difft - (mydbl)(1.0*difftfrw); /*Pointer to file where solution of differential equation will be saved.*/ FILE *geodesic; geodesic = fopen("geodesic_solution.dat","w"); /*Write line of initial values in file*/ fprintf(geodesic, "%16.8Le %16.8Le %16.8Le %16.8Le %16.8Le %16.8Le %16.8Le %16.8Le %16.8e %16.8Le\n", lambda, x0, r, p0, pr, energy1, v, difft, difftfrw, difference); long long int ii; /*Solution of the differential equation*/ for(ii=0; ii< NSTEPS; ii++) { runge_kutta_4(spline1, acc1, spline2, acc2, &x0, &r, &p0, &pr, &lambda); if((ii%(NSTEPS/NLINES)) == 0) { energy = C*energy_factor(r)*p0; difft = (energy - energy1)/energy1; ti = x0/C; aobs = interpolator(spline1, (double)(1.0*ti), acc1); v = violation(r, p0, pr, aobs); difftfrw = (aem/aobs) - 1.0; difference = difft - (mydbl)(1.0*difftfrw); fprintf(geodesic, "%16.8Le %16.8Le %16.8Le %16.8Le %16.8Le %16.8Le %16.8Le %16.8Le %16.8e %16.8Le\n", lambda, x0, r, p0, pr, energy, v, difft, difftfrw, difference); } } /************************************************************************************/ /*** Releasing all used space in memory ***/ fclose(geodesic); //Close file storing the results gsl_spline_free(spline1); //Free memory of spline object gsl_spline_free(spline2); gsl_interp_accel_free(acc1); //Free memory of accel object gsl_interp_accel_free(acc2); }
void legion_network::calculate_states(const legion_stimulus & stimulus, const solve_type solver, const double t, const double step, const double int_step) { std::vector<void *> argv(2, NULL); std::vector<differ_result<double> > next_states(size()); argv[0] = (void *) this; unsigned int number_int_steps = (unsigned int) (step / int_step); for (unsigned int index = 0; index < size(); index++) { argv[1] = (void *) &index; differ_state<double> inputs { m_oscillators[index].m_excitatory, m_oscillators[index].m_inhibitory }; if (m_params.ENABLE_POTENTIAL) { inputs.push_back(m_oscillators[index].m_potential); } switch(solver) { case solve_type::FAST: { throw std::runtime_error("Forward Euler first-order method is not supported due to low accuracy."); } case solve_type::RK4: { if (m_params.ENABLE_POTENTIAL) { runge_kutta_4(&legion_network::adapter_neuron_states, inputs, t, t + step, number_int_steps, false /* only last states */, argv, next_states[index]); } else { runge_kutta_4(&legion_network::adapter_neuron_simplify_states, inputs, t, t + step, number_int_steps, false /* only last states */, argv, next_states[index]); } break; } case solve_type::RKF45: { if (m_params.ENABLE_POTENTIAL) { runge_kutta_fehlberg_45(&legion_network::adapter_neuron_states, inputs, t, t + step, 0.00001, false /* only last states */, argv, next_states[index]); } else { runge_kutta_fehlberg_45(&legion_network::adapter_neuron_simplify_states, inputs, t, t + step, 0.00001, false /* only last states */, argv, next_states[index]); } break; } default: { throw std::runtime_error("Unknown type of solver"); } } std::vector<unsigned int> * neighbors = get_neighbors(index); double coupling = 0.0; for (std::vector<unsigned int>::const_iterator index_neighbor_iterator = neighbors->begin(); index_neighbor_iterator != neighbors->end(); index_neighbor_iterator++) { coupling += m_dynamic_connections[index][*index_neighbor_iterator] * heaviside(m_oscillators[*index_neighbor_iterator].m_excitatory - m_params.teta_x); } delete neighbors; m_oscillators[index].m_buffer_coupling_term = coupling - m_params.Wz * heaviside(m_global_inhibitor - m_params.teta_xz); } differ_result<double> inhibitor_next_state; differ_state<double> inhibitor_input { m_global_inhibitor }; switch (solver) { case solve_type::RK4: { runge_kutta_4(&legion_network::adapter_inhibitor_state, inhibitor_input, t, t + step, number_int_steps, false /* only last states */, argv, inhibitor_next_state); break; } case solve_type::RKF45: { runge_kutta_fehlberg_45(&legion_network::adapter_inhibitor_state, inhibitor_input, t, t + step, 0.00001, false /* only last states */, argv, inhibitor_next_state); break; } } m_global_inhibitor = inhibitor_next_state[0].state[0]; for (unsigned int i = 0; i < size(); i++) { m_oscillators[i].m_excitatory = next_states[i][0].state[0]; m_oscillators[i].m_inhibitory = next_states[i][0].state[1]; if (m_params.ENABLE_POTENTIAL) { m_oscillators[i].m_potential = next_states[i][0].state[2]; } m_oscillators[i].m_coupling_term = m_oscillators[i].m_buffer_coupling_term; m_oscillators[i].m_noise = m_noise_distribution(m_generator); } }
int main() { printf("Welcome to Chiu Industries. q1b finding critical damping value vs initial velocity duffing Pendulum Calculator. NO Driving Force Mode. \n"); FILE *output_file; FILE *output_file_damp; //declarations of variables int number_of_steps; double initial_x, initial_v, final_t, E_initial; double h; double y[2], dydt[2], yout[2]; double t; double gamma; double period_initial = 10.0; int printInterval = 10; int printCounter = 0; double count; int negValueFinder = 0; initial_v = -50.1; int outsidecount; output_file_damp = fopen("damping_vi_5.dat", "w"); for(outsidecount = 0; outsidecount<11; outsidecount++) { double damp = 10.0; printf("\n %d \n", outsidecount); //output_damp(output_file_damp, initial_v, damp); //output_file = fopen("finalq1a_rk4_vinitial_0pt1_gamma_neg0pt1_v1.dat", "w"); //THIS IS WHRE COUNT USED TO BE BELOW gamma = 0.1; for(count = 0; count<3000; count++) { negValueFinder = 0; //THIS IS WHERE COUNT USED TO BE ABOVE // filenamemaker(output_file, damp); double d = damp; char somenumber[50]; sprintf(somenumber,"%2.5f", d); char str_output[20]= {0}, str_two[]=".dat"; strcpy(str_output, "finalq1b_damp_"); // copies "one" into str_output strcat(str_output, somenumber); strcat(str_output, "_vi_"); strcat(str_output, ".dat"); // attaches str_two to str_output //printf("The Output string is: %s", str_output); // output_file = fopen(str_output, "w"); t = 0.0; // fprintf(output_file, "Damping constant is: \n"); // fprintf(output_file, "#%12.5E \n", damp); //fprintf(output_file, "#%12.10E \n", gamma); final_t = period_initial*10.0; h = 0.05; number_of_steps = final_t/h; initial_x = 0.0; //initial_v = 0.1; assert(number_of_steps >0); //initialise position and velocity y[0] = initial_x; y[1] = initial_v; E_initial = 0.5*y[0]*y[0] + 0.5*y[1]*y[1]; t=0.0; //output(output_file, h, t, y, E_initial, initial_v); while(t<=final_t) { derivatives(t,y,dydt, damp); //euler(y, dydt, 2, t, h, yout); runge_kutta_4(y, dydt, 2, t, h, yout, derivatives); y[0]=yout[0]; y[1]=yout[1]; if(y[0]<0) { negValueFinder++; } if(printCounter == printInterval) { // output(output_file, h, t, y, E_initial, damp); printCounter = 0; } else {} printCounter++; t+=h; } if(negValueFinder==0) { printf("At value of %lf is critical damping!", damp); // fprintf(output_file, "\n At value of %lf is critical damping!", damp); output_damp(output_file_damp, initial_v, damp); break; //fclose(output_file); //return 0; } //initial_v = initial_v+1.0; damp = damp + 0.01; //fclose(output_file); } initial_v=initial_v+10.0; } fclose(output_file_damp); return 0; } //end main program