model_manager.h

Go to the documentation of this file.

/*
 *  model_manager.h
 *
 *  This file is part of NEST.
 *
 *  Copyright (C) 2004 The NEST Initiative
 *
 *  NEST is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  NEST is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with NEST.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef MODEL_MANAGER_H
#define MODEL_MANAGER_H
 
// C++ includes:
#include <string>
 
// Includes from nestkernel:
#include "connector_model.h"
#include "genericmodel.h"
#include "manager_interface.h"
#include "model.h"
#include "nest.h"
#include "nest_time.h"
#include "nest_timeconverter.h"
#include "nest_types.h"
#include "node.h"
 
 
namespace nest
{
 
class ModelManager : public ManagerInterface
{
public:
  ModelManager();
  ~ModelManager() override;
 
  void initialize( const bool ) override;
  void finalize( const bool ) override;
  void set_status( const Dictionary& ) override;
  void get_status( Dictionary& ) override;
 
  void calibrate( const TimeConverter& );
 
  Node* get_proxy_node( size_t tid, size_t node_id );
 
  ConnectorModel& get_connection_model( synindex syn_id, size_t thread_id );
 
  const std::vector< ConnectorModel* >& get_connection_models( size_t tid );
 
  template < class ModelT >
  size_t register_node_model( const std::string& name, std::string deprecation_info = std::string() );
 
  template < template < typename targetidentifierT > class ConnectionT >
  void register_connection_model( const std::string& name );
 
  void copy_model( const std::string& old_name, const std::string& new_name, const Dictionary& params );
 
  bool set_model_defaults( const std::string& name, const Dictionary& params );
 
  size_t get_node_model_id( const std::string ) const;
 
  Model* get_node_model( size_t ) const;
 
  size_t get_synapse_model_id( std::string model_name );
 
  Dictionary get_connector_defaults( synindex syn_id ) const;
 
  void set_connector_defaults( synindex syn_id, const Dictionary& d );
 
  void assert_valid_syn_id( synindex syn_id, size_t t ) const;
 
  bool are_model_defaults_modified() const;
 
  size_t get_num_connection_models() const;
 
  void memory_info() const;
 
  std::unique_ptr< SecondaryEvent > get_secondary_event_prototype( const synindex syn_id, const size_t tid );
 
private:
  void clear_node_models_();
 
  void clear_connection_models_();
 
  size_t register_node_model_( Model* model );
 
  template < typename CompleteConnecionT >
  void register_specific_connection_model_( const std::string& name );
 
  void copy_node_model_( const size_t old_id, const std::string& new_name, const Dictionary& params );
 
  void copy_connection_model_( const size_t old_id, const std::string& new_name, const Dictionary& params );
 
  void set_node_defaults_( size_t model_id, const Dictionary& params );
 
  void set_synapse_defaults_( size_t model_id, const Dictionary& params );
 
  static bool compare_model_by_id_( const int a, const int b );
 
  std::vector< Model* > node_models_;
 
  std::vector< std::vector< ConnectorModel* > > connection_models_;
 
  Dictionary modeldict_;    
  Dictionary synapsedict_;  
 
  Model* proxynode_model_;
 
  Node* create_proxynode_( size_t t, int model_id );
 
  std::vector< std::vector< Node* > > proxy_nodes_;
  bool model_defaults_modified_;
};
 
 
inline Model*
ModelManager::get_node_model( size_t m ) const
{
  assert( m < node_models_.size() );
  return node_models_[ m ];
}
 
inline bool
ModelManager::are_model_defaults_modified() const
{
  return model_defaults_modified_;
}
 
inline ConnectorModel&
ModelManager::get_connection_model( synindex syn_id, size_t thread_id )
{
  assert_valid_syn_id( syn_id, thread_id );
  return *( connection_models_[ thread_id ][ syn_id ] );
}
 
inline const std::vector< ConnectorModel* >&
ModelManager::get_connection_models( size_t tid )
{
  return connection_models_[ tid ];
}
 
inline void
ModelManager::assert_valid_syn_id( synindex syn_id, size_t t ) const
{
  if ( syn_id >= connection_models_[ t ].size() or not connection_models_[ t ][ syn_id ] )
  {
    throw UnknownSynapseType( syn_id );
  }
}
 
inline std::unique_ptr< SecondaryEvent >
ModelManager::get_secondary_event_prototype( const synindex syn_id, const size_t tid )
{
  assert_valid_syn_id( syn_id, tid );
  return get_connection_model( syn_id, tid ).get_secondary_event();
}
 
}  // namespace nest
 
#endif /* MODEL_MANAGER_H */