void nest::iaf_cond_exp::init_buffers_() { B_.spike_exc_.clear(); // includes resize B_.spike_inh_.clear(); // includes resize B_.currents_.clear(); // includes resize Archiving_Node::clear_history(); B_.logger_.reset(); B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; if ( B_.s_ == 0 ) B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); else gsl_odeiv_step_reset( B_.s_ ); if ( B_.c_ == 0 ) B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); else gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); if ( B_.e_ == 0 ) B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); else gsl_odeiv_evolve_reset( B_.e_ ); B_.sys_.function = iaf_cond_exp_dynamics; B_.sys_.jacobian = NULL; B_.sys_.dimension = State_::STATE_VEC_SIZE; B_.sys_.params = reinterpret_cast< void* >( this ); B_.I_stim_ = 0.0; }
static void odesys_odegsl_reset (odegsl_t * odegsl) { gsl_odeiv_evolve_reset (odegsl->evolve); gsl_odeiv_step_reset (odegsl->step); odegsl->hstep = odegsl->hinit; }
void nest::aeif_cond_exp::init_buffers_() { B_.spike_exc_.clear(); // includes resize B_.spike_inh_.clear(); // includes resize B_.currents_.clear(); // includes resize Archiving_Node::clear_history(); B_.logger_.reset(); B_.step_ = Time::get_resolution().get_ms(); // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); if ( B_.s_ == 0 ) B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); else gsl_odeiv_step_reset( B_.s_ ); if ( B_.c_ == 0 ) B_.c_ = gsl_odeiv_control_yp_new( P_.gsl_error_tol, P_.gsl_error_tol ); else gsl_odeiv_control_init( B_.c_, P_.gsl_error_tol, P_.gsl_error_tol, 0.0, 1.0 ); if ( B_.e_ == 0 ) B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); else gsl_odeiv_evolve_reset( B_.e_ ); B_.I_stim_ = 0.0; }
static VALUE rb_gsl_odeiv_solver_reset(VALUE obj) { gsl_odeiv_solver *gos = NULL; Data_Get_Struct(obj, gsl_odeiv_solver, gos); gsl_odeiv_step_reset(gos->s); gsl_odeiv_evolve_reset(gos->e); return obj; }
static PyObject * PyGSL_odeiv_evolve_reset(PyGSL_odeiv_evolve *self, PyObject *args) { assert(PyGSL_ODEIV_EVOLVE_Check(self)); gsl_odeiv_evolve_reset(self->evolve); Py_INCREF(Py_None); return Py_None; }
void nest::iaf_cond_alpha_mc::init_buffers_() { B_.spikes_.resize( NUM_SPIKE_RECEPTORS ); for ( size_t n = 0; n < NUM_SPIKE_RECEPTORS; ++n ) { B_.spikes_[ n ].clear(); } // includes resize B_.currents_.resize( NUM_CURR_RECEPTORS ); for ( size_t n = 0; n < NUM_CURR_RECEPTORS; ++n ) { B_.currents_[ n ].clear(); } // includes resize B_.logger_.reset(); Archiving_Node::clear_history(); B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; if ( B_.s_ == 0 ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } else { gsl_odeiv_step_reset( B_.s_ ); } if ( B_.c_ == 0 ) { B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); } else { gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); } if ( B_.e_ == 0 ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } else { gsl_odeiv_evolve_reset( B_.e_ ); } B_.sys_.function = iaf_cond_alpha_mc_dynamics; B_.sys_.jacobian = NULL; B_.sys_.dimension = State_::STATE_VEC_SIZE; B_.sys_.params = reinterpret_cast< void* >( this ); for ( size_t n = 0; n < NCOMP; ++n ) { B_.I_stim_[ n ] = 0.0; } }
void nest::hh_psc_alpha_gap::init_buffers_() { B_.spike_exc_.clear(); // includes resize B_.spike_inh_.clear(); // includes resize B_.currents_.clear(); // includes resize // allocate strucure for gap events here // function is called from Scheduler::prepare_nodes() before the // first call to update // so we already know which interpolation scheme to use according // to the properties of this neurons // determine size of structure depending on interpolation scheme // and unsigned int Scheduler::min_delay() (number of simulation time steps // per min_delay step) // resize interpolation_coefficients depending on interpolation order const size_t quantity = kernel().connection_manager.get_min_delay() * ( kernel().simulation_manager.get_wfr_interpolation_order() + 1 ); B_.interpolation_coefficients.resize( quantity, 0.0 ); B_.last_y_values.resize( kernel().connection_manager.get_min_delay(), 0.0 ); B_.sumj_g_ij_ = 0.0; Archiving_Node::clear_history(); B_.logger_.reset(); B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; if ( B_.s_ == 0 ) B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); else gsl_odeiv_step_reset( B_.s_ ); if ( B_.c_ == 0 ) B_.c_ = gsl_odeiv_control_y_new( 1e-6, 0.0 ); else gsl_odeiv_control_init( B_.c_, 1e-6, 0.0, 1.0, 0.0 ); if ( B_.e_ == 0 ) B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); else gsl_odeiv_evolve_reset( B_.e_ ); B_.sys_.function = hh_psc_alpha_gap_dynamics; B_.sys_.jacobian = NULL; B_.sys_.dimension = State_::STATE_VEC_SIZE; B_.sys_.params = reinterpret_cast< void* >( this ); B_.I_stim_ = 0.0; }
void nest::aeif_psc_alpha::init_buffers_() { B_.spike_exc_.clear(); // includes resize B_.spike_inh_.clear(); // includes resize B_.currents_.clear(); // includes resize Archiving_Node::clear_history(); B_.logger_.reset(); B_.step_ = Time::get_resolution().get_ms(); // We must integrate this model with high-precision to obtain decent results B_.IntegrationStep_ = std::min( 0.01, B_.step_ ); if ( B_.s_ == 0 ) { B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); } else { gsl_odeiv_step_reset( B_.s_ ); } if ( B_.c_ == 0 ) { B_.c_ = gsl_odeiv_control_yp_new( P_.gsl_error_tol, P_.gsl_error_tol ); } else { gsl_odeiv_control_init( B_.c_, P_.gsl_error_tol, P_.gsl_error_tol, 0.0, 1.0 ); } if ( B_.e_ == 0 ) { B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); } else { gsl_odeiv_evolve_reset( B_.e_ ); } B_.sys_.jacobian = NULL; B_.sys_.dimension = State_::STATE_VEC_SIZE; B_.sys_.params = reinterpret_cast< void* >( this ); B_.sys_.function = aeif_psc_alpha_dynamics; B_.I_stim_ = 0.0; }
void func_fdf(double t_end, void *_par, double* f, double* df) { odesolver_t* par = (odesolver_t*) _par; // Safety check if(t_end < 0.) { fprintf(stderr, "Warning: value requested at t < 0!\n"); *f = 0.; *df = 0.; return; } while(t_end < par->points[par->cur_idx].t) par->cur_idx--; double t = par->points[par->cur_idx].t; double h = 1e-6; // xdot, ydot, x, y double y[4]; y[0] = par->points[par->cur_idx].y[0]; y[1] = par->points[par->cur_idx].y[1]; y[2] = par->points[par->cur_idx].y[2]; y[3] = par->points[par->cur_idx].y[3]; gsl_odeiv_evolve_reset(par->e); while(t < t_end) gsl_odeiv_evolve_apply(par->e, par->c, par->s, &par->sys, &t, t_end, &h, y); *f = y[2] - y[3]; *df = y[0] - y[1]; par->cur_idx++; if(par->cur_idx >= CACHE_SIZE) { fprintf(stderr, "Warning: cache size too small!\n"); par->cur_idx = CACHE_SIZE - 1; } par->points[par->cur_idx].t = t; par->points[par->cur_idx].y[0] = y[0]; par->points[par->cur_idx].y[1] = y[1]; par->points[par->cur_idx].y[2] = y[2]; par->points[par->cur_idx].y[3] = y[3]; }
void GslInternal::reset(int fsens_order, int asens_order){ if(monitored("reset")){ cout << "initial state: " << endl; cout << "p = " << input(INTEGRATOR_P) << endl; cout << "x0 = " << input(INTEGRATOR_X0) << endl; } // Reset timers t_res = t_fres = t_jac = t_lsolve = t_lsetup_jac = t_lsetup_fac = 0; // Get the time horizon t_ = t0_; int flag = gsl_odeiv_evolve_reset(evolve_ptr); if(flag!=GSL_SUCCESS) gsl_error("Reset",flag); output(INTEGRATOR_XF).set(input(INTEGRATOR_X0)); }
//Handles data from MarkovChannel class. void MarkovGslSolver::init( vector< double > initialState ) { nVars_ = initialState.size(); if ( stateGsl_ == 0 ) stateGsl_ = new double[ nVars_ ]; state_ = initialState; initialState_ = initialState; Q_.resize( nVars_ ); for ( unsigned int i = 0; i < nVars_; ++i ) Q_[i].resize( nVars_, 0.0 ); isInitialized_ = 1; assert( gslStepType_ != 0 ); if ( gslStep_ ) gsl_odeiv_step_free(gslStep_); gslStep_ = gsl_odeiv_step_alloc( gslStepType_, nVars_ ); assert( gslStep_ != 0 ); if ( !gslEvolve_ ) gslEvolve_ = gsl_odeiv_evolve_alloc(nVars_); else gsl_odeiv_evolve_reset(gslEvolve_); assert(gslEvolve_ != 0); if ( !gslControl_ ) gslControl_ = gsl_odeiv_control_y_new( absAccuracy_, relAccuracy_ ); else gsl_odeiv_control_init(gslControl_,absAccuracy_, relAccuracy_, 1, 0); assert(gslControl_!= 0); gslSys_.function = &MarkovGslSolver::evalSystem; gslSys_.jacobian = 0; gslSys_.dimension = nVars_; gslSys_.params = static_cast< void * >( &Q_ ); }
void nest::ht_neuron::init_buffers_() { // Reset spike buffers. for ( std::vector< RingBuffer >::iterator it = B_.spike_inputs_.begin(); it != B_.spike_inputs_.end(); ++it ) { it->clear(); // include resize } B_.currents_.clear(); // include resize B_.logger_.reset(); Archiving_Node::clear_history(); B_.step_ = Time::get_resolution().get_ms(); B_.IntegrationStep_ = B_.step_; if ( B_.s_ == 0 ) B_.s_ = gsl_odeiv_step_alloc( gsl_odeiv_step_rkf45, State_::STATE_VEC_SIZE ); else gsl_odeiv_step_reset( B_.s_ ); if ( B_.c_ == 0 ) B_.c_ = gsl_odeiv_control_y_new( 1e-3, 0.0 ); else gsl_odeiv_control_init( B_.c_, 1e-3, 0.0, 1.0, 0.0 ); if ( B_.e_ == 0 ) B_.e_ = gsl_odeiv_evolve_alloc( State_::STATE_VEC_SIZE ); else gsl_odeiv_evolve_reset( B_.e_ ); B_.sys_.function = ht_neuron_dynamics; B_.sys_.jacobian = 0; B_.sys_.dimension = State_::STATE_VEC_SIZE; B_.sys_.params = reinterpret_cast< void* >( this ); B_.I_stim_ = 0.0; }
static VALUE rb_gsl_odeiv_evolve_reset(VALUE obj) { gsl_odeiv_evolve *e = NULL; Data_Get_Struct(obj, gsl_odeiv_evolve, e); return INT2FIX(gsl_odeiv_evolve_reset(e)); }
void pert_ode_reset (pert_ode * po) { gsl_odeiv_step_reset (po->se); gsl_odeiv_evolve_reset (po->ee); }
void do_simulation (const gsl_vector *proposed_vars, void *params_raw) { struct experiment_params *params = params_raw; double ball_diameter, ball_mass, rho; double proposed_speed, proposed_angle; double state[params->simulator_dimen]; double prev_state[params->simulator_dimen]; double t, prev_t, frame_secs, step_size; int fine_mode; ball_diameter = 0.063; ball_mass = 0.05; rho = 1.29; params->alpha = M_PI*(ball_diameter*ball_diameter)/(8*ball_mass)*rho; #if 0 etha = 1; /* spin direction */ w = 20; /* spin speed */ #endif proposed_speed = gsl_vector_get (proposed_vars, 0); proposed_angle = gsl_vector_get (proposed_vars, 1); state[0] = 0; // x state[1] = params->observed_hit[2]; // z state[2] = proposed_speed * cos(proposed_angle); // dx state[3] = proposed_speed * sin(proposed_angle); // dz gsl_odeiv_evolve_reset (params->evolver); t = 0; frame_secs = .030; step_size = 1e-6; fine_mode = 0; while (1) { memcpy (prev_state, state, sizeof state); prev_t = t; if (gsl_odeiv_evolve_apply (params->evolver, params->controller, params->stepper, ¶ms->odesys, &t, t + frame_secs, &step_size, state) != GSL_SUCCESS) { fprintf (stderr, "evolve error\n"); exit (1); } if (state[1] < 0) { fine_mode++; if (fine_mode > 4) break; memcpy (state, prev_state, sizeof state); t = prev_t; frame_secs /= 10; } if (vflag && fine_mode == 0) fprintf (outf, "%.14g %.14g\n", state[0], state[1]); } if (vflag) { fprintf (outf, "%.14g %.14g\n", prev_state[0], prev_state[1]); } params->sim_dist = prev_state[0]; params->sim_secs = prev_t; }