nest.h

Go to the documentation of this file.

/*
 *  nest.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 NEST_H
#define NEST_H
 
// C++ includes:
#include <ostream>
 
// Includes from libnestutil:
#include "dictionary.h"
#include "enum_bitfield.h"
#include "logging.h"
 
// Includes from nestkernel:
#include "connection_id.h"
#include "mask.h"
#include "mask_impl.h"
#include "nest_time.h"
#include "nest_types.h"
#include "parameter.h"
#include "random_generators.h"
 
namespace nest
{
 
template < template < typename > class ConnectorModelT >
void register_connection_model( const std::string& name );
 
void init_nest( int* argc, char** argv[] );
void shutdown_nest( int exitcode );
 
void install_module( const std::string& module_name );
 
void reset_kernel();
 
void enable_structural_plasticity();
void disable_structural_plasticity();
 
void register_logger_client( const deliver_logging_event_ptr client_callback );
 
std::string print_nodes_to_string();
 
std::string pprint_to_string( NodeCollectionPTR nc );
 
size_t nc_size( NodeCollectionPTR nc );
 
void set_kernel_status( const Dictionary& dict );
Dictionary get_kernel_status();
 
Dictionary get_nc_status( NodeCollectionPTR node_collection );
void set_nc_status( NodeCollectionPTR nc, std::vector< Dictionary >& params );
 
void set_node_status( const size_t node_id, const Dictionary& dict );
Dictionary get_node_status( const size_t node_id );
 
void set_connection_status( const std::deque< ConnectionID >& conns, const Dictionary& dict );
void set_connection_status( const std::deque< ConnectionID >& conns, const std::vector< Dictionary >& dicts );
std::vector< Dictionary > get_connection_status( const std::deque< ConnectionID >& conns );
 
NodeCollectionPTR slice_nc( const NodeCollectionPTR nc, long start, long stop, long step );
 
NodeCollectionPTR create( const std::string& model_name, const size_t n );
NodeCollectionPTR create_spatial( const Dictionary& layer_dict );
 
NodeCollectionPTR make_nodecollection( const std::vector< size_t >& node_ids );
 
NodeCollectionPTR get_nodes( const Dictionary& dict, const bool local_only );
long find( const NodeCollectionPTR nc, size_t node_id );
Dictionary get_metadata( const NodeCollectionPTR nc );
 
bool equal( const NodeCollectionPTR lhs, const NodeCollectionPTR rhs );
bool contains( const NodeCollectionPTR nc, const size_t node_id );
 
template < typename NodeModelT >
void register_node_model( const std::string& name, std::string deprecation_info = std::string() );
 
void print_nodes_to_stream( std::ostream& out = std::cout );
 
RngPtr get_rank_synced_rng();
RngPtr get_vp_synced_rng( size_t tid );
RngPtr get_vp_specific_rng( size_t tid );
 
void set_kernel_status( const Dictionary& dict );
Dictionary get_kernel_status();
 
void connect( NodeCollectionPTR sources,
  NodeCollectionPTR targets,
  const Dictionary& connectivity,
  const std::vector< Dictionary >& synapse_params );
 
void disconnect( NodeCollectionPTR sources,
  NodeCollectionPTR targets,
  const Dictionary& connectivity,
  const std::vector< Dictionary >& synapse_params );
 
void connect_tripartite( NodeCollectionPTR sources,
  NodeCollectionPTR targets,
  NodeCollectionPTR third,
  const Dictionary& connectivity,
  const Dictionary& third_connectivity,
  const std::map< std::string, std::vector< Dictionary > >& synapse_specs );
 
void connect_arrays( const long* sources,
  const long* targets,
  const double* weights,
  const double* delays,
  const std::vector< std::string >& p_keys,
  const double* p_values,
  size_t n,
  const std::string& syn_model );
 
void connect_sonata( const Dictionary& graph_specs, const long hyperslab_size );
 
std::deque< ConnectionID > get_connections( const Dictionary& dict );
 
void disconnect( const std::deque< ConnectionID >& conns );
 
void simulate( const double t );
 
void run( const double t );
 
void prepare();
 
void cleanup();
 
void synchronize();
 
MaskPTR create_mask( const std::string& name, const Dictionary& d );
 
void copy_model( const std::string& oldmodname, const std::string& newmodname, const Dictionary& dict );
 
void set_model_defaults( const std::string& model_name, const Dictionary& );
Dictionary get_model_defaults( const std::string& model_name );
 
ParameterPTR create_parameter( const any_type& );
ParameterPTR create_parameter( const double );
ParameterPTR create_parameter( const long );
ParameterPTR create_parameter( const Dictionary& param_dict );
ParameterPTR create_parameter( const std::string& name, const Dictionary& d );
 
using ParameterFactory = GenericFactory< Parameter >;
using MaskFactory = GenericFactory< AbstractMask >;
using MaskCreatorFunction = MaskFactory::CreatorFunction;
 
ParameterFactory& parameter_factory_();
MaskFactory& mask_factory_();
 
double get_value( const ParameterPTR param );
bool is_spatial( const ParameterPTR param );
 
std::vector< double > apply( const ParameterPTR param, const NodeCollectionPTR nc );
std::vector< double > apply( const ParameterPTR param, const Dictionary& positions );
 
NodeCollectionPTR node_collection_array_index( NodeCollectionPTR node_collection, const long* array, unsigned long n );
NodeCollectionPTR node_collection_array_index( NodeCollectionPTR node_collection, const bool* array, unsigned long n );
 
// for debugging and testing mostly
std::vector< size_t > node_collection_to_array( NodeCollectionPTR node_collection, const std::string& selection );
 
template < class T >
inline bool
register_parameter( const std::string& name )
{
  return parameter_factory_().register_subtype< T >( name );
}
 
template < class T >
inline bool
register_mask()
{
  return mask_factory_().register_subtype< T >( T::get_name() );
}
 
inline bool
register_mask( const std::string& name, MaskCreatorFunction creator )
{
  return mask_factory_().register_subtype( name, creator );
}
 
inline MaskPTR
create_mask( const std::string& name, const Dictionary& d )
{
  d.init_access_flags();
  auto mask = MaskPTR( mask_factory_().create( name, d ) );
  d.all_entries_accessed( "CreateMask", "specs" );
  return mask;
}
 
void message( const VerbosityLevel, const std::string&, const std::string&, const std::string&, const size_t );
 
}  // namespace nest
 
#endif /* NEST_H */