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