nestmodule.h

Go to the documentation of this file.

/*
 *  nestmodule.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 NESTMODULE_H
#define NESTMODULE_H

#include "slimodule.h"
#include "slitype.h" 
#include "slifunction.h"
#include "dict.h"

#include "network.h"
#include "scheduler.h"
#include "event.h"
#include "exceptions.h"

namespace nest
{
   class Node;
   
   class NestModule: public SLIModule
   {
    public:

     static SLIType ConnectionType;
     static SLIType GIDCollectionType;

     NestModule();
     ~NestModule();

     static void register_network(Network&);

     void init(SLIInterpreter *);

     const std::string commandstring(void) const;
     const std::string name(void) const;


     static Network &get_network();

     static index get_num_threads(); 
     
     
     
     class ChangeSubnet_iFunction: public SLIFunction
     { 
      public:
       void execute(SLIInterpreter *) const;
     } changesubnet_ifunction;
  
     class CurrentSubnetFunction: public SLIFunction
     { 
      public:
       void execute(SLIInterpreter *) const;
     } currentsubnetfunction;
  
     class GetNodes_i_D_b_bFunction: public SLIFunction
     { 
      public:
       void execute(SLIInterpreter *) const;
     } getnodes_i_D_b_bfunction;

     class GetLeaves_i_D_bFunction: public SLIFunction
     { 
      public:
       void execute(SLIInterpreter *) const;
     } getleaves_i_D_bfunction;

     class GetChildren_i_D_bFunction: public SLIFunction
     { 
      public:
       void execute(SLIInterpreter *) const;
     } getchildren_i_D_bfunction;

     class GetStatus_iFunction: public SLIFunction
     { 
      public:
       void execute(SLIInterpreter *) const;
     } getstatus_ifunction;

     class GetStatus_CFunction: public SLIFunction
     { 
      public:
       void execute(SLIInterpreter *) const;
     } getstatus_Cfunction;

     class GetStatus_aFunction: public SLIFunction
     { 
      public:
       void execute(SLIInterpreter *) const;
     } getstatus_afunction;

     class SetStatus_idFunction: public SLIFunction
     { 
      public:
       void execute(SLIInterpreter *) const;
     } setstatus_idfunction;

     class SetStatus_CDFunction: public SLIFunction
     { 
      public:
       void execute(SLIInterpreter *) const;
     } setstatus_CDfunction;

     class Cva_CFunction: public SLIFunction
     { 
      public:
       void execute(SLIInterpreter *) const;
     } cva_cfunction;

      class SetStatus_aaFunction: public SLIFunction
     { 
      public:
       void execute(SLIInterpreter *) const;
     } setstatus_aafunction;
    
     class SetDefaults_l_DFunction: public SLIFunction
     { 
      public:
       void execute(SLIInterpreter *) const;
     } setdefaults_l_Dfunction;
     
     class GetDefaults_lFunction: public SLIFunction
     { 
      public:
       void execute(SLIInterpreter *) const;
     } getdefaults_lfunction;

     class CopyModel_l_l_DFunction: public SLIFunction
     {
      public:
       void execute(SLIInterpreter *) const;
     } copymodel_l_l_Dfunction;

     class GetConnections_DFunction: public SLIFunction
     {
      public:
       void execute(SLIInterpreter *) const;
     } getconnections_Dfunction;

     class SimulateFunction: public SLIFunction
     { 
      public:
       void execute(SLIInterpreter *) const;
     } simulatefunction;

     class ResumeSimulationFunction: public SLIFunction
     { 
      public:
       void execute(SLIInterpreter *) const;
     } resumesimulationfunction;
  
     class Create_l_iFunction: public SLIFunction
     { 
      public:
       void execute(SLIInterpreter *) const;
     } create_l_ifunction;

     class RestoreNodes_aFunction: public SLIFunction
     { 
      public:
       void execute(SLIInterpreter *) const;
     } restorenodes_afunction;

     class DataConnect_i_D_sFunction: public SLIFunction
     {
      public:
       void execute(SLIInterpreter *) const;
     } dataconnect_i_D_sfunction;

     class DataConnect_aFunction: public SLIFunction
     {
      public:
       void execute(SLIInterpreter *) const;
     } dataconnect_afunction;

     class Connect_i_i_lFunction: public SLIFunction
     {
      public:
       void execute(SLIInterpreter *) const;
     } connect_i_i_lfunction;

     class Connect_i_i_d_d_lFunction: public SLIFunction
     {
      public:
       void execute(SLIInterpreter *) const;
     } connect_i_i_d_d_lfunction;

     class Connect_i_i_D_lFunction: public SLIFunction
     {
      public:
       void execute(SLIInterpreter *) const;
     } connect_i_i_D_lfunction;

     class Connect_g_g_D_DFunction: public SLIFunction
     {
     public:
       void execute(SLIInterpreter *) const;
     } connect_g_g_D_Dfunction;

     class DivergentConnect_i_ia_a_a_lFunction: public SLIFunction
     {
      public:
       void execute(SLIInterpreter *) const;
     } divergentconnect_i_ia_a_a_lfunction;

     class RDivergentConnect_i_i_ia_da_da_b_b_lFunction: public SLIFunction
     {
      public:
       void execute(SLIInterpreter *) const;
     } rdivergentconnect_i_i_ia_da_da_b_b_lfunction;
          
     class ConvergentConnect_ia_i_a_a_lFunction: public SLIFunction
     {
      public:
       void execute(SLIInterpreter *) const;
     } convergentconnect_ia_i_a_a_lfunction;

     class RConvergentConnect_ia_i_i_da_da_b_b_lFunction: public SLIFunction
     {
      public:
       void execute(SLIInterpreter *) const;
     } rconvergentconnect_ia_i_i_da_da_b_b_lfunction;

     class RConvergentConnect_ia_ia_ia_daa_daa_b_b_lFunction: public SLIFunction
     {
      public:
       void execute(SLIInterpreter *) const;
     } rconvergentconnect_ia_ia_ia_daa_daa_b_b_lfunction;

     class ResetKernelFunction: public SLIFunction
     { 
      public:
       void execute(SLIInterpreter *) const;
     } resetkernelfunction;

     class ResetNetworkFunction: public SLIFunction
     { 
      public:
       void execute(SLIInterpreter *) const;
     } resetnetworkfunction;

     class MemoryInfoFunction: public SLIFunction
     {
       void execute(SLIInterpreter *) const;
     } memoryinfofunction;

     class PrintNetworkFunction : public SLIFunction
     {
       void execute(SLIInterpreter *) const;
     } printnetworkfunction;

     class RankFunction : public SLIFunction
     {
       void execute(SLIInterpreter *) const;
     } rankfunction;

     class NumProcessesFunction : public SLIFunction
     {
       void execute(SLIInterpreter *) const;
     } numprocessesfunction;

     class SetFakeNumProcessesFunction_i : public SLIFunction
     {
       void execute(SLIInterpreter *) const;
     } setfakenumprocesses_ifunction;

     class SetNumRecProcessesFunction_i : public SLIFunction
     {
       void execute(SLIInterpreter *) const;
     } setnumrecprocesses_ifunction;

     class SyncProcessesFunction : public SLIFunction
     {
       void execute(SLIInterpreter *) const;
     } syncprocessesfunction;

     class TimeCommunication_i_i_bFunction : public SLIFunction 
     { 
       void execute(SLIInterpreter *) const; 
     } timecommunication_i_i_bfunction; 
     
     class TimeCommunicationv_i_iFunction : public SLIFunction 
     { 
       void execute(SLIInterpreter *) const; 
     } timecommunicationv_i_ifunction; 

     class TimeCommunicationAlltoall_i_iFunction : public SLIFunction 
     { 
       void execute(SLIInterpreter *) const; 
     } timecommunicationalltoall_i_ifunction; 

     class TimeCommunicationAlltoallv_i_iFunction : public SLIFunction 
     { 
       void execute(SLIInterpreter *) const; 
     } timecommunicationalltoallv_i_ifunction; 

     class ProcessorNameFunction : public SLIFunction
     {
       void execute(SLIInterpreter *) const;
     } processornamefunction;

#ifdef HAVE_MPI
     class MPIAbort_iFunction : public SLIFunction
     {
       void execute(SLIInterpreter *) const;
     } mpiabort_ifunction;
#endif

     class GetVpRngFunction : public SLIFunction
     {
       void execute(SLIInterpreter *) const;
     } getvprngfunction;

     class GetGlobalRngFunction : public SLIFunction
     {
       void execute(SLIInterpreter *) const;
     } getglobalrngfunction;

     class Cvdict_CFunction : public SLIFunction
     {
       void execute(SLIInterpreter *) const;
     } cvdict_Cfunction;

     class Cvgidcollection_i_iFunction : public SLIFunction
     {
       void execute(SLIInterpreter *) const;
     } cvgidcollection_i_ifunction;

     class Cvgidcollection_iaFunction : public SLIFunction
     {
       void execute(SLIInterpreter *) const;
     } cvgidcollection_iafunction;

     class Cvgidcollection_ivFunction : public SLIFunction
     {
       void execute(SLIInterpreter *) const;
     } cvgidcollection_ivfunction;

     class Size_gFunction: public SLIFunction
     {
       void execute(SLIInterpreter *) const;
     } size_gfunction;

#ifdef HAVE_MUSIC     
     class SetAcceptableLatencyFunction : public SLIFunction
     {
       void execute(SLIInterpreter *) const;
     } setacceptablelatency_l_dfunction;

     class SetMaxBufferedFunction : public SLIFunction
     {
       void execute(SLIInterpreter *) const;
     } setmaxbuffered_l_ifunction;
#endif


   private:

     static Network *net_;
   };

  inline
  Network &NestModule::get_network()
  {
    assert(net_ != 0);
    return *net_;
  }

  inline
  index NestModule::get_num_threads()
  {
    if ( net_ == 0 )
      return 1;  // module not initialized, thus certainly single thread
    else  
      return net_->get_num_threads();
  }

} // namespace

#endif