void
aeif_cond_alpha_multisynapse::State_::get( DictionaryDatum& d ) const
{
  def< double >( d, names::V_m, y_[ V_M ] );

  std::vector< double_t >* g_exc = new std::vector< double_t >();
  std::vector< double_t >* dg_exc = new std::vector< double_t >();
  std::vector< double_t >* g_inh = new std::vector< double_t >();
  std::vector< double_t >* dg_inh = new std::vector< double_t >();

  for ( size_t i = 0; i < ( ( y_.size() - State_::NUMBER_OF_FIXED_STATES_ELEMENTS )
                            / State_::NUMBER_OF_STATES_ELEMENTS_PER_RECEPTOR );
        ++i )
  {
    g_exc->push_back(
      y_[ State_::G_EXC + ( State_::NUMBER_OF_STATES_ELEMENTS_PER_RECEPTOR * i ) ] );
    dg_exc->push_back(
      y_[ State_::DG_EXC + ( State_::NUMBER_OF_STATES_ELEMENTS_PER_RECEPTOR * i ) ] );
    g_inh->push_back(
      y_[ State_::G_INH + ( State_::NUMBER_OF_STATES_ELEMENTS_PER_RECEPTOR * i ) ] );
    dg_inh->push_back(
      y_[ State_::DG_INH + ( State_::NUMBER_OF_STATES_ELEMENTS_PER_RECEPTOR * i ) ] );
  }

  ( *d )[ names::g_ex ] = DoubleVectorDatum( g_exc );
  ( *d )[ names::dg_ex ] = DoubleVectorDatum( dg_exc );
  ( *d )[ names::g_in ] = DoubleVectorDatum( g_inh );
  ( *d )[ names::dg_in ] = DoubleVectorDatum( dg_inh );

  def< double >( d, names::w, y_[ W ] );
}
void
nest::music_cont_in_proxy::get_status( DictionaryDatum& d ) const
{
  P_.get( d );
  S_.get( d );

  ( *d )[ "data" ] = DoubleVectorDatum( new std::vector< double >( B_.data_ ) );
}
Beispiel #3
0
void nest::iaf_chs_2007::Parameters_::get(DictionaryDatum &d) const
{
  def<double>(d, names::V_reset,    U_reset_);
  def<double>(d, names::V_epsp,     U_epsp_);
  def<double>(d, names::tau_epsp,   tau_epsp_);
  def<double>(d, names::tau_reset,  tau_reset_);
  def<double>(d, names::V_noise,    U_noise_);
  (*d)[names::noise] = DoubleVectorDatum(new std::vector<double>(noise_));

}
Beispiel #4
0
void nest::spike_generator::Parameters_::get(DictionaryDatum &d) const
{
    const size_t n_spikes = spike_stamps_.size();
    const size_t n_offsets = spike_offsets_.size();
    assert(   ( precise_times_ && n_offsets == n_spikes )
              || (!precise_times_ && n_offsets == 0        ) );

    std::vector<double_t>* times_ms = new std::vector<double_t>();
    times_ms->reserve(n_spikes);
    for ( size_t n = 0 ; n < n_spikes ; ++n )
    {
        times_ms->push_back(spike_stamps_[n].get_ms());
        if ( precise_times_ )
            (*times_ms)[n] -= spike_offsets_[n];
    }
    (*d)[names::spike_times] = DoubleVectorDatum(times_ms);
    (*d)["spike_weights"] = DoubleVectorDatum(new std::vector<double_t>(spike_weights_));
    (*d)[names::precise_times] = BoolDatum(precise_times_);
    (*d)["allow_offgrid_spikes"] = BoolDatum(allow_offgrid_spikes_);
    (*d)["shift_now_spikes"] = BoolDatum(shift_now_spikes_);
}