/**
* Set properties of this connection from position p in the properties
* array given in dictionary.
*/
void ContDelayConnection::set_status(const DictionaryDatum & d, index p, ConnectorModel &cm)
{
//set delay if mentioned
double_t delay;
if ( set_property<double_t>(d, names::delays, p, delay) )
{
double_t h = Time::get_resolution().get_ms();
double_t int_delay;
double_t frac_delay = std::modf(delay/h, &int_delay);
if (frac_delay == 0)
{
if (!cm.check_delay(delay))
throw BadDelay(delay);
delay_ = Time(Time::ms(delay)).get_steps();
delay_offset_ = 0.0;
}
else
{
long_t lowerbound = static_cast<long_t>(int_delay);
if (!cm.check_delays(Time(Time::step(lowerbound)).get_ms(),
Time(Time::step(lowerbound + 1)).get_ms()))
throw BadDelay(lowerbound);
delay_ = lowerbound + 1;
delay_offset_ = h * (1.0 - frac_delay);
}
}
set_property<double_t>(d, names::weights, p, weight_);
}
void
nest::DelayChecker::assert_two_valid_delays_steps( delay new_delay1,
delay new_delay2 )
{
const delay ldelay = std::min( new_delay1, new_delay2 );
const delay hdelay = std::max( new_delay1, new_delay2 );
if ( ldelay < Time::get_resolution().get_steps() )
throw BadDelay( Time::delay_steps_to_ms( ldelay ),
"Delay must be greater than or equal to resolution" );
if ( kernel().simulation_manager.has_been_simulated() )
{
const bool bad_min_delay =
ldelay < kernel().connection_manager.get_min_delay();
const bool bad_max_delay =
hdelay > kernel().connection_manager.get_max_delay();
if ( bad_min_delay )
throw BadDelay( Time::delay_steps_to_ms( ldelay ),
"Minimum delay cannot be changed after Simulate has been called." );
if ( bad_max_delay )
throw BadDelay( Time::delay_steps_to_ms( hdelay ),
"Maximum delay cannot be changed after Simulate has been called." );
}
const bool new_min_delay = ldelay < min_delay_.get_steps();
const bool new_max_delay = hdelay > max_delay_.get_steps();
if ( new_min_delay )
{
if ( user_set_delay_extrema_ )
{
throw BadDelay( Time::delay_steps_to_ms( ldelay ),
"Delay must be greater than or equal to min_delay. "
"You may set min_delay before creating connections." );
}
else
{
if ( not freeze_delay_update_ )
min_delay_ = Time( Time::step( ldelay ) );
}
}
if ( new_max_delay )
{
if ( user_set_delay_extrema_ )
{
throw BadDelay( Time::delay_steps_to_ms( hdelay ),
"Delay must be smaller than or equal to max_delay. "
"You may set max_delay before creating connections." );
}
else
{
if ( not freeze_delay_update_ )
max_delay_ = Time( Time::step( hdelay ) );
}
}
}
void
nest::DelayChecker::assert_valid_delay_ms( double_t requested_new_delay )
{
const delay new_delay = Time::delay_ms_to_steps( requested_new_delay );
const double new_delay_ms = Time::delay_steps_to_ms( new_delay );
if ( new_delay < Time::get_resolution().get_steps() )
throw BadDelay(
new_delay_ms, "Delay must be greater than or equal to resolution" );
// if already simulated, the new delay has to be checked against the
// min_delay and the max_delay which have been used during simulation
if ( kernel().simulation_manager.has_been_simulated() )
{
const bool bad_min_delay =
new_delay < kernel().connection_manager.get_min_delay();
const bool bad_max_delay =
new_delay > kernel().connection_manager.get_max_delay();
if ( bad_min_delay || bad_max_delay )
throw BadDelay( new_delay_ms,
"Minimum and maximum delay cannot be changed "
"after Simulate has been called." );
}
const bool new_min_delay = new_delay < min_delay_.get_steps();
const bool new_max_delay = new_delay > max_delay_.get_steps();
if ( new_min_delay )
{
if ( user_set_delay_extrema_ )
{
throw BadDelay( new_delay_ms,
"Delay must be greater than or equal to min_delay. "
"You may set min_delay before creating connections." );
}
else
{
if ( not freeze_delay_update_ )
min_delay_ = Time( Time::step( new_delay ) );
}
}
if ( new_max_delay )
{
if ( user_set_delay_extrema_ )
{
throw BadDelay( new_delay_ms,
"Delay must be smaller than or equal to max_delay. "
"You may set min_delay before creating connections." );
}
else
{
if ( not freeze_delay_update_ )
max_delay_ = Time( Time::step( new_delay ) );
}
}
}
void
nest::DelayChecker::set_status( const DictionaryDatum& d )
{
// For the minimum delay, we always round down. The easiest way to do this,
// is to round up and then subtract one step. The only remaining edge case
// is that the min delay is exactly at a step, in which case one would get
// a min delay that is one step too small. We can detect this by an
// additional test.
double_t delay_tmp = 0.0;
bool min_delay_updated = updateValue< double_t >( d, "min_delay", delay_tmp );
Time new_min_delay;
if ( min_delay_updated )
{
delay new_min_delay_steps = Time( Time::ms_stamp( delay_tmp ) ).get_steps();
if ( Time( Time::step( new_min_delay_steps ) ).get_ms() > delay_tmp )
{
new_min_delay_steps -= 1;
}
new_min_delay = Time( Time::step( new_min_delay_steps ) );
}
// For the maximum delay, we always round up, using ms_stamp
bool max_delay_updated = updateValue< double_t >( d, "max_delay", delay_tmp );
Time new_max_delay = Time( Time::ms_stamp( delay_tmp ) );
if ( min_delay_updated xor max_delay_updated )
{
throw BadProperty( "Both min_delay and max_delay have to be specified" );
}
if ( min_delay_updated && max_delay_updated )
{
if ( kernel().connection_manager.get_num_connections() > 0 )
{
throw BadProperty(
"Connections already exist. Please call ResetKernel first" );
}
else if ( new_min_delay < Time::get_resolution() )
{
throw BadDelay( new_min_delay.get_ms(),
"min_delay must be greater than or equal to resolution." );
}
else if ( new_max_delay < new_min_delay )
{
throw BadDelay( new_min_delay.get_ms(),
"min_delay must be smaller than or equal to max_delay." );
}
else
{
min_delay_ = new_min_delay;
max_delay_ = new_max_delay;
user_set_delay_extrema_ = true;
}
}
}
void CommonPropertiesHomWD::set_status(const DictionaryDatum & d, ConnectorModel &cm)
{
CommonSynapseProperties::set_status(d, cm);
double_t delay;
if (updateValue<double_t>(d, names::delay, delay))
{
if (!cm.check_delay(delay))
throw BadDelay(delay);
delay_ = Time(Time::ms(delay)).get_steps();
}
updateValue<double_t>(d, names::weight, weight_);
}
