index
ModelManager::copy_model( Name old_name, Name new_name, DictionaryDatum params )
{
if ( modeldict_->known( new_name ) || synapsedict_->known( new_name ) )
throw NewModelNameExists( new_name );
const Token oldnodemodel = modeldict_->lookup( old_name );
const Token oldsynmodel = synapsedict_->lookup( old_name );
index new_id;
if ( !oldnodemodel.empty() )
{
index old_id = static_cast< index >( oldnodemodel );
new_id = copy_node_model_( old_id, new_name );
set_node_defaults_( new_id, params );
}
else if ( !oldsynmodel.empty() )
{
index old_id = static_cast< index >( oldsynmodel );
new_id = copy_synapse_model_( old_id, new_name );
set_synapse_defaults_( new_id, params );
}
else
throw UnknownModelName( old_name );
return new_id;
}
Selector::Selector( const DictionaryDatum& d )
: model( -1 )
, depth( -1 )
{
if ( updateValue< long >( d, names::lid, depth ) )
{
if ( depth <= 0 )
throw BadProperty( "lid must be >0" );
depth -= 1; // lid starts at 1 for backwards compatibility
}
std::string modelname;
if ( updateValue< std::string >( d, names::model, modelname ) )
{
const Token model_token =
kernel().model_manager.get_modeldict()->lookup( modelname );
if ( model_token.empty() )
throw UnknownModelName( modelname );
model = static_cast< long >( model_token );
}
}
DictionaryDatum
get_model_defaults( const Name& modelname )
{
const Token nodemodel = kernel().model_manager.get_modeldict()->lookup( modelname );
const Token synmodel = kernel().model_manager.get_synapsedict()->lookup( modelname );
DictionaryDatum dict;
if ( !nodemodel.empty() )
{
const long model_id = static_cast< long >( nodemodel );
Model* m = kernel().model_manager.get_model( model_id );
dict = m->get_status();
}
else if ( !synmodel.empty() )
{
const long synapse_id = static_cast< long >( synmodel );
dict = kernel().model_manager.get_connector_defaults( synapse_id );
}
else
{
throw UnknownModelName( modelname.toString() );
}
return dict;
}
ArrayDatum
ConnectionManager::get_connections( DictionaryDatum params ) const
{
ArrayDatum connectome;
const Token& source_t = params->lookup( names::source );
const Token& target_t = params->lookup( names::target );
const Token& syn_model_t = params->lookup( names::synapse_model );
const TokenArray* source_a = 0;
const TokenArray* target_a = 0;
if ( not source_t.empty() )
source_a = dynamic_cast< TokenArray const* >( source_t.datum() );
if ( not target_t.empty() )
target_a = dynamic_cast< TokenArray const* >( target_t.datum() );
size_t syn_id = 0;
#ifdef _OPENMP
std::string msg;
msg = String::compose( "Setting OpenMP num_threads to %1.", net_.get_num_threads() );
net_.message( SLIInterpreter::M_DEBUG, "ConnectionManager::get_connections", msg );
omp_set_num_threads( net_.get_num_threads() );
#endif
// First we check, whether a synapse model is given.
// If not, we will iterate all.
if ( not syn_model_t.empty() )
{
Name synmodel_name = getValue< Name >( syn_model_t );
const Token synmodel = synapsedict_->lookup( synmodel_name );
if ( !synmodel.empty() )
syn_id = static_cast< size_t >( synmodel );
else
throw UnknownModelName( synmodel_name.toString() );
get_connections( connectome, source_a, target_a, syn_id );
}
else
{
for ( syn_id = 0; syn_id < prototypes_[ 0 ].size(); ++syn_id )
{
ArrayDatum conn;
get_connections( conn, source_a, target_a, syn_id );
if ( conn.size() > 0 )
connectome.push_back( new ArrayDatum( conn ) );
}
}
return connectome;
}
index
create( const Name& model_name, const index n_nodes )
{
if ( n_nodes == 0 )
{
throw RangeCheck();
}
const Token model = kernel().model_manager.get_modeldict()->lookup( model_name );
if ( model.empty() )
throw UnknownModelName( model_name );
// create
const index model_id = static_cast< index >( model );
return kernel().node_manager.add_node( model_id, n_nodes );
}
void
ModelManager::set_model_defaults( Name name, DictionaryDatum params )
{
const Token nodemodel = modeldict_->lookup( name );
const Token synmodel = synapsedict_->lookup( name );
index id;
if ( !nodemodel.empty() )
{
id = static_cast< index >( nodemodel );
set_node_defaults_( id, params );
}
else if ( !synmodel.empty() )
{
id = static_cast< index >( synmodel );
set_synapse_defaults_( id, params );
}
else
throw UnknownModelName( name );
model_defaults_modified_ = true;
}
index AbstractLayer::create_layer(const DictionaryDatum & layer_dict)
{
index length = 0;
const char *layer_model_name = 0;
std::vector<long_t> element_ids;
std::string element_name;
Token element_model;
const Token& t = layer_dict->lookup(names::elements);
ArrayDatum* ad = dynamic_cast<ArrayDatum *>(t.datum());
if (ad) {
for (Token* tp = ad->begin(); tp != ad->end(); ++tp) {
element_name = std::string(*tp);
element_model = net_->get_modeldict().lookup(element_name);
if ( element_model.empty() )
throw UnknownModelName(element_name);
// Creates several nodes if the next element in
// the elements variable is a number.
if ((tp+1 != ad->end()) && dynamic_cast<IntegerDatum*>((tp+1)->datum())) {
// Select how many nodes that should be created.
const long_t number = getValue<long_t>(*(++tp));
for(long_t i=0;i<number;++i)
element_ids.push_back(static_cast<long>(element_model));
} else {
element_ids.push_back(static_cast<long>(element_model));
}
}
} else {
element_name = getValue<std::string>(layer_dict, names::elements);
element_model = net_->get_modeldict().lookup(element_name);
if ( element_model.empty() )
throw UnknownModelName(element_name);
element_ids.push_back(static_cast<long>(element_model));
}
if (layer_dict->known(names::positions)) {
if (layer_dict->known(names::rows) or layer_dict->known(names::columns) or layer_dict->known(names::layers))
throw BadProperty("Can not specify both positions and rows or columns.");
TokenArray positions = getValue<TokenArray>(layer_dict, names::positions);
if (positions.size() == 0) {
throw BadProperty("Empty positions array.");
}
std::vector<double_t> pos = getValue<std::vector<double_t> >(positions[0]);
if (pos.size() == 2)
layer_model_name = "topology_layer_free";
else if (pos.size() == 3)
layer_model_name = "topology_layer_free_3d";
else
throw BadProperty("Positions must have 2 or 3 coordinates.");
length = positions.size();
} else if (layer_dict->known(names::columns)) {
if (not layer_dict->known(names::rows)) {
throw BadProperty("Both columns and rows must be given.");
}
length=getValue<long_t>(layer_dict, names::columns) * getValue<long_t>(layer_dict, names::rows);
if (layer_dict->known(names::layers)) {
layer_model_name = "topology_layer_grid_3d";
length *= getValue<long_t>(layer_dict, names::layers);
} else {
layer_model_name = "topology_layer_grid";
}
} else {
throw BadProperty("Unknown layer type.");
}
assert(layer_model_name != 0);
Token layer_model = net_->get_modeldict().lookup(layer_model_name);
if ( layer_model.empty() )
throw UnknownModelName(layer_model_name);
index layer_node = net_->add_node(layer_model);
// Remember original subnet
const index cwnode = net_->get_cwn()->get_gid();
net_->go_to(layer_node);
// Create layer nodes.
for ( size_t i = 0 ; i < element_ids.size() ; ++i )
{
for ( index n = 0 ; n < length ; ++n )
{
net_->add_node(element_ids[i]);
}
}
// Return to original subnet
net_->go_to(cwnode);
//Set layer parameters according to input dictionary.
AbstractLayer *layer = dynamic_cast<AbstractLayer *>(net_->get_node(layer_node));
layer->depth_ = element_ids.size();
layer->set_status(layer_dict);
return layer_node;
}
