SimNetwork.h

Go to the documentation of this file.

#ifndef SIMNETWORK_H_
#define SIMNETWORK_H_

#include <mpi.h>

#ifndef SWIG

#include <iostream>
using std::cerr;
using std::endl;

#endif

#include <vector>

#include <cstdlib>

#include "SimObject.h"
#include "SimParameter.h"
#include "SimEngine.h"
#include "DistributionStrategy.h"
#include "PCSIMException.h"
#include "SimTime.h"
#include "RandomEngine.h"
#include "init.h"

class WiringMethodSelector;
class ConnectionIterator;

class SimNetwork
{

    //

public:
    SimNetwork( MPI::Intracomm &mpiCommunicator, SimParameter sp, DistributionStrategy::DistributionFunction *df );
    virtual ~SimNetwork();

    //


public:

    void addObject( const SimObjectFactory &model, const SimEngine::ID &engine, SimObject::ID &id )
    {
        _addObject_( model, engine, id );
    }

protected:
    virtual void _addObject_( const SimObjectFactory &model, const SimEngine::ID &engine, SimObject::ID &id )
    {}
    ;

public:

    void addObject( const SimObjectFactory &model, SimObject::ID &id )
    {
        _addObject_( model, id );
    }

protected:
    virtual void _addObject_( const SimObjectFactory &model, SimObject::ID &id )
    {}
    ;

public:
    SimObject::ID::Packed create( const SimObjectFactory &model, const SimEngine::ID &engine );
    SimObject::ID::Packed add
    ( const SimObjectFactory &model, const SimEngine::ID &engine );

    SimObject::ID::Packed create( const SimObjectFactory &model );
    SimObject::ID::Packed add
    ( const SimObjectFactory &model );


    //

public:
    /*
     *  \param model A model (factory) which specifis how the instance of the object to be added is created.
     *  \param id  The resulting unique identifier (node,engine,type,localid) of the created object.
     */
    void mount( const SimObjectFactory &model, const SimObject::ID &mountpoint, SimObject::ID &gid );

    SimObject::ID::Packed mount( const SimObjectFactory &model, const SimObject::ID &mountpoint );

    SimObject::ID::Packed mount( const SimObjectFactory &model, const SimObject::ID::Packed &mountpoint );

    SimObject::ID::Vector mount( const SimObjectFactory &model, std::vector<SimObject::ID::Packed> const& mountpoints, bool collect = false );

protected:

    virtual void _mount_( const SimObjectFactory &model, const SimObject::ID &mountpoint, SimObject::ID &gid )
    {}
    ;

public:
    /*
     *  \param model A model (factory) which specifis how the instance of the object to be added is created.
     *  \param id  The resulting unique identifier (node,engine,type,localid) of the created object.
     */
    void insert( const SimObjectFactory &model, const SimObject::ID &container, SimObject::ID &gid );

    SimObject::ID::Packed insert( const SimObjectFactory &model, const SimObject::ID &container );

    SimObject::ID::Packed insert( const SimObjectFactory &model, const SimObject::ID::Packed &container );

protected:

    virtual void _insert_( const SimObjectFactory &model, const SimObject::ID &container, SimObject::ID &gid )
    {}
    ;


    //

public:
    SimObject::ID::Vector create( SimObjectFactory const& model, std::vector<SimEngine::ID> const& engines );
    SimObject::ID::Vector add
    ( SimObjectFactory const& model, std::vector<SimEngine::ID> const& engines );

    SimObject::ID::Vector create( SimObjectFactory const& model, unsigned const n);
    SimObject::ID::Vector add
    ( SimObjectFactory const& model, unsigned const n);

    void setDistributionStrategy( DistributionStrategy::DistributionFunction* distFunc );



    //

public:
    void connect( const SimObject::ID &src, const port_t out, const SimObject::ID &dst, const port_t in, const Time &delay );
    void connect( const SimObject::ID::Packed &src, const port_t out, const SimObject::ID::Packed &dst, const port_t in, const Time &delay );
    void connect( const SimObject::ID &src, const port_t out, const SimObject::ID &dst, const port_t in  );
    void connect( const SimObject::ID::Packed &src, const port_t out, const SimObject::ID::Packed &dst, const port_t in  );

    //

public:
    void connect( const SimObject::ID &src, const port_t out, const SimObject::ID &dst, const string in, const Time &delay );
    void connect( const SimObject::ID::Packed &src, const port_t out, const SimObject::ID::Packed &dst, const string in, const Time &delay );
    void connect( const SimObject::ID &src, const string out, const SimObject::ID &dst, const port_t in, const Time &delay );
    void connect( const SimObject::ID::Packed &src, const string out, const SimObject::ID::Packed &dst, const port_t in, const Time &delay );
    void connect( const SimObject::ID &src, const string out, const SimObject::ID &dst, const string in, const Time &delay );
    void connect( const SimObject::ID::Packed &src, const string out, const SimObject::ID::Packed &dst, const string in, const Time &delay );


    //

public:
    void connect( const SimObject::ID &src, const SimObject::ID &dst, const Time &delay );
    void connect( const SimObject::ID::Packed &src, const SimObject::ID::Packed &dst, const Time &delay );
    void connect( const SimObject::ID &src, const SimObject::ID &dst );
    void connect( const SimObject::ID::Packed &src, const SimObject::ID::Packed &dst );

    //

public:
    void connect( const SimObject::ID &src, const SimObject::ID &dst, const SimObjectFactory &connObjFactory, SimObject::ID &connID );
    SimObject::ID connect( const SimObject::ID &src, const SimObject::ID &dst, const SimObjectFactory &connObjFactory );
    SimObject::ID::Packed connect( const SimObject::ID::Packed &src, const SimObject::ID::Packed &dst, const SimObjectFactory &connObjFactory );

    //

public:
    unsigned connect( std::vector<SimObject::ID::Packed> const& src, std::vector<SimObject::ID::Packed> const& dst, const Time &delay);



public:
    unsigned connect( std::vector<SimObject::ID::Packed> const& src, std::vector<SimObject::ID::Packed> const& dst, ConnectionIterator & decider);


    //

public:
    SimObject::ID::Vector connect( std::vector<SimObject::ID::Packed> const& src, std::vector<SimObject::ID::Packed> const& dst, const SimObjectFactory &model, ConnectionIterator & decider, bool collect = false );

    SimObject::ID::Vector connectFast( std::vector<SimObject::ID::Packed> const& sources, std::vector<SimObject::ID::Packed> const& destinations, const SimObjectFactory &model, ConnectionIterator & decider, bool collect = false);

    //
    //
public:
    SimObject::ID::Packed record(const SimObject::ID::Packed & obj, const SimObjectFactory &recFactory, const port_t rec_port = 0 );
    SimObject::ID::Packed record(const SimObject::ID::Packed & obj, const port_t src_port, const SimObjectFactory &recFactory, const port_t rec_port = 0 );
    SimObject::ID::Packed record(const SimObject::ID::Packed & obj, const string field, const SimObjectFactory &recFactory, const port_t rec_port = 0);

protected:

    virtual void _connect_( SimObject::ID const& src, port_t out, const SimObject::ID &dst, port_t in, int delay )
    {}
    ;


    //


public:
    void addSpikeMessage(const SimObject::ID &sender, const port_t out, const SimObject::ID &receiver, const port_t in, const Time &delay )
    {
        _addSpikeMessage_( sender, out, receiver, in, delay );
    };

    void addAnalogMessage(const SimObject::ID &sender, int sender_port, const SimObject::ID &receiver, int recv_port, const Time &delay)
    {
        _addAnalogMessage_( sender, sender_port, receiver, recv_port, delay );
    };

    void addAnalogMessage(const SimObject::ID &sender, int sender_port, const SimObject::ID &receiver, string destfield, const Time &delay)
    {
        _addAnalogMessage_( sender, sender_port, receiver, destfield, delay );
    };

    void addAnalogMessage(const SimObject::ID &sender, string srcfield, const SimObject::ID &receiver, int recv_port, const Time &delay)
    {
        _addAnalogMessage_( sender, srcfield, receiver, recv_port, delay );
    };

    void addAnalogMessage(const SimObject::ID &sender, string srcfield, const SimObject::ID &receiver, string destfield, const Time &delay)
    {
        _addAnalogMessage_( sender, srcfield, receiver, destfield, delay );
    };

protected:

    virtual void _addSpikeMessage_(const SimObject::ID &sender, const port_t out, const SimObject::ID &receiver, const port_t in, const Time &delay )
    {}
    ;
    virtual void _addAnalogMessage_(const SimObject::ID &sender, int sender_port, const SimObject::ID &receiver, int recv_port, const Time &delay)
    {}
    ;
    virtual void _addAnalogMessage_(const SimObject::ID &sender, int sender_port, const SimObject::ID &receiver, string destfield, const Time &delay)
    {}
    ;
    virtual void _addAnalogMessage_(const SimObject::ID &sender, string srcfield, const SimObject::ID &receiver, int recv_port, const Time &delay)
    {}
    ;
    virtual void _addAnalogMessage_(const SimObject::ID &sender, string srcfield, const SimObject::ID &receiver, string destfield, const Time &delay)
    {}
    ;


    //


public:

    template< class T >
    bool getObject( const SimObject::ID &id, T &p );

    template< class T >
    bool getObject( const SimObject::ID::Packed &id, T &p );

    SimObject *object(const SimObject::ID &id);
    SimObject *object(const SimObject::ID::Packed &id);

    SimObject *getObject(const SimObject::ID &id)
    {
        return _getObject_( id );
    }

protected:

    virtual SimObject *_getObject_(const SimObject::ID &id)
    {
        return NULL;
    };


    //


public:
    void initialize()
    {
        _initialize_();
    };

protected:

    virtual void _initialize_()
    {}
    ;

public:

    void reset()
    {
        _reset_();
    };

protected:

    virtual void _reset_()
    {}
    ;

public:

    void advance(int nSteps = 1)
    {
        _advance_( nSteps );
    };

    void simulate( const Time &T )
    {
        _advance_(  T.in_steps( get_dt() ) );
    };

    void simulate( double T )
    {
        _advance_(  int( T / get_dt().in_sec() + 0.5  ) );
    };

protected:

    virtual void _advance_(int nSteps = 1)
    {}
    ;

public:

    void set_dt(const Time &dt);

    Time get_dt() const;

public:

    int mpi_rank()
    {
        return _mpi_rank;
    };

    int mpi_size()
    {
        return _mpi_size;
    };

    unsigned nSpikeMessage()
    {
        return _nSpikeMessages;
    };

    unsigned nAnalogMessages()
    {
        return _nAnalogMessages;
    };

    const SimParameter& simParameter()
    {
        return simParam;
    };

    RandomEngine * getMainConstructRNGEngine()
    {
        return constructMainRNDEngine;
    };

    std::vector< RandomEngine* > & getIncomingConstructRNGEngines()
    {
        return constructIncomingRNGEngines;
    }

    std::vector< RandomEngine* > & getOutgoingConstructRNGEngines()
    {
        return constructOutgoingRNGEngines;
    }

    RandomEngine *  getObjectVariationRNDEngine()
    {
        return objectVariationRNDEngine;
    }

    void seed( uint32 noiseRNGseed )
    {
        seed_noise_rng( noiseRNGseed );
    };

public:
    virtual gl_engineid_t maxLocalEngineID(void) const
    {
        return 0;
    };

protected:

    virtual void _change_timestep_width_(const Time &old_dt, const Time &new_dt)
    {
        /* NOOP */
    };

    SimParameter simParam;

    DistributionStrategy::DistributionFunction* distributionStrategy;

    int _mpi_rank;

    int _mpi_size;

    bool initialized;

    bool reseted;

    unsigned _nSpikeMessages;

    unsigned _nAnalogMessages;

    virtual uint32 getUniqueSeedOverMpi( uint32 seed );

    uint32 makeSeed( uint32 seed_or_negative );

    virtual void seed_noise_rng( uint32 noiseRNGseed )
    {}
    ;

    void fillSeedVector( uint32 noiseRNGseed,  std::vector<uint32> &sim_seeds );

    typedef LaggedFibonacci607 simRNGSeedGenerator_t;
    simRNGSeedGenerator_t simRNGSeedGenerator;
    uint32 getSeedFromGenerator();

    void setupConstructRNGEngines();

    RandomEngine *constructMainRNDEngine;

    RandomEngine *objectVariationRNDEngine;

    std::vector< RandomEngine * > constructIncomingRNGEngines;
    std::vector< RandomEngine * > constructOutgoingRNGEngines;

private:
    friend class NoiseRandomEngineTest;
    virtual void noiseRandEngineOutput( std::vector<uint32> & r )
    {}
    ;
    WiringMethodSelector *wiringMethods;

};

#ifndef SWIG

inline SimObject::ID::Packed SimNetwork::add
( const SimObjectFactory &model, const SimEngine::ID &engine )
{
    SimObject::ID id;
    addObject( model, engine, id );
    return id.packed();
}

inline SimObject::ID::Packed SimNetwork::add
( const SimObjectFactory &model )
{
    SimObject::ID id;
    addObject( model, id );
    return id.packed();
}

// Aliases for add

inline SimObject::ID::Packed SimNetwork::create( const SimObjectFactory &model, const SimEngine::ID &engine )
{
    return add
           ( model, engine );
}

inline SimObject::ID::Packed SimNetwork::create( const SimObjectFactory &model )
{
    return add
           ( model );
}

inline SimObject::ID::Vector SimNetwork::create( SimObjectFactory const& model, std::vector<SimEngine::ID> const& engines )
{
    return add
           ( model, engines );
}

inline SimObject::ID::Vector SimNetwork::create( SimObjectFactory const& model, unsigned const n)
{
    return add
           ( model, n );
}

inline void SimNetwork::mount( const SimObjectFactory &model, const SimObject::ID &mountpoint, SimObject::ID &gid )
{
    _mount_( model, mountpoint, gid );
}


inline SimObject::ID::Packed  SimNetwork::mount( const SimObjectFactory &model, const SimObject::ID &mountpoint )
{
    SimObject::ID id;
    mount( model, mountpoint, id);
    return id.packed();
}

inline SimObject::ID::Packed  SimNetwork::mount( const SimObjectFactory &model, const SimObject::ID::Packed &mountpoint )
{
    SimObject::ID id;
    mount( model, *reinterpret_cast<const SimObject::ID*>(&mountpoint), id);
    return id.packed();
}

inline void SimNetwork::insert( const SimObjectFactory &model, const SimObject::ID &container, SimObject::ID &gid )
{
    _insert_( model, container, gid );
}

inline SimObject::ID::Packed SimNetwork::insert( const SimObjectFactory &model, const SimObject::ID &container )
{
    SimObject::ID id;
    insert( model, container, id);
    return id.packed();
}

inline SimObject::ID::Packed SimNetwork::insert( const SimObjectFactory &model, const SimObject::ID::Packed &container )
{
    SimObject::ID id;
    insert( model, *reinterpret_cast<const SimObject::ID*>(&container), id);
    return id.packed();
}


inline void SimNetwork::setDistributionStrategy( DistributionStrategy::DistributionFunction* distFunc )
{
    distributionStrategy = distFunc;
}


inline void SimNetwork::connect( const SimObject::ID &src, const port_t out, const SimObject::ID &dst, const port_t in, const Time & delay )
{
    _connect_( src, out, dst, in, delay.in_steps( get_dt() ) );
}


inline void SimNetwork::connect( const SimObject::ID::Packed &src, const port_t out, const SimObject::ID::Packed &dst, const port_t in, const Time & delay )
{
    _connect_( *reinterpret_cast<const SimObject::ID*>(&src), out, *reinterpret_cast<const SimObject::ID*>(&dst), in, delay.in_steps( get_dt() ) );
}


inline void SimNetwork::connect( const SimObject::ID &src, const port_t out, const SimObject::ID &dst, const port_t in  )
{
    _connect_( src, out, dst, in, -1 );
}


inline void SimNetwork::connect( const SimObject::ID::Packed &src, const port_t out, const SimObject::ID::Packed &dst, const port_t in  )
{
    _connect_( *reinterpret_cast<const SimObject::ID*>(&src), out, *reinterpret_cast<const SimObject::ID*>(&dst), in, -1 );
}

/*
 * \param src The sending object
 * \param dst The receiving object
 * \param delay Specifies how much the message should be delayed
 */
inline void SimNetwork::connect( const SimObject::ID &src, const SimObject::ID &dst, const Time & delay )
{
    _connect_( src, 0, dst, 0, delay.in_steps( get_dt() ) );
}

/*
 * \param src The sending object
 * \param dst The receiving object
 * \param delay Specifies how much the message should be delayed
 */
inline void SimNetwork::connect( const SimObject::ID::Packed &src, const SimObject::ID::Packed &dst, const Time & delay )
{
    _connect_( *reinterpret_cast<const SimObject::ID*>(&src), 0, *reinterpret_cast<const SimObject::ID*>(&dst), 0, delay.in_steps( get_dt() ) );
}


inline void SimNetwork::connect( const SimObject::ID &src, const SimObject::ID &dst )
{
    _connect_( src, 0, dst, 0, -1 );
}


inline void SimNetwork::connect( const SimObject::ID::Packed &src, const SimObject::ID::Packed &dst )
{
    _connect_( *reinterpret_cast<const SimObject::ID*>(&src), 0, *reinterpret_cast<const SimObject::ID*>(&dst), 0, -1 );
}


inline void SimNetwork::connect( const SimObject::ID &src, const SimObject::ID &dst, const SimObjectFactory &connector, SimObject::ID &connID )
{
    _insert_( connector, dst, connID );
    _connect_( src, 0, connID, 0, -1 );
}


inline SimObject::ID SimNetwork::connect( const SimObject::ID &src, const SimObject::ID &dst, const SimObjectFactory &connector )
{
    SimObject::ID id;
    connect( src, dst, connector, id );
    return id;
}


inline SimObject::ID::Packed SimNetwork::connect( const SimObject::ID::Packed &src, const SimObject::ID::Packed &dst, const SimObjectFactory &connector )
{
    SimObject::ID id;
    connect( *reinterpret_cast<const SimObject::ID*>(&src), *reinterpret_cast<const SimObject::ID*>(&dst), connector, id );
    return id.packed();
}



inline void SimNetwork::connect( const SimObject::ID &src, const port_t out, const SimObject::ID &dest, const string in, const Time &delay )
{
    addAnalogMessage(src, out, dest, in, delay);
}


inline void SimNetwork::connect( const SimObject::ID::Packed &src, const port_t out, const SimObject::ID::Packed &dest, const string in, const Time &delay )
{
    addAnalogMessage(reinterpret_cast<const SimObject::ID&>(src), out, reinterpret_cast<const SimObject::ID&>(dest), in, delay);
}


inline void SimNetwork::connect( const SimObject::ID &src, const string out, const SimObject::ID &dest, const port_t in, const Time &delay )
{
    addAnalogMessage(src, out, dest, in, delay);
}


inline void SimNetwork::connect( const SimObject::ID::Packed &src, const string out, const SimObject::ID::Packed &dest, const port_t in, const Time &delay )
{
    addAnalogMessage(reinterpret_cast<const SimObject::ID&>(src), out, reinterpret_cast<const SimObject::ID&>(dest), in, delay);
}


inline void SimNetwork::connect( const SimObject::ID &src, const string out, const SimObject::ID &dest, const string in, const Time &delay )
{
    addAnalogMessage(src, out, dest, in, delay);
}


inline void SimNetwork::connect( const SimObject::ID::Packed &src, const string out, const SimObject::ID::Packed &dest, const string in, const Time &delay )
{
    addAnalogMessage(reinterpret_cast<const SimObject::ID&>(src), out, reinterpret_cast<const SimObject::ID&>(dest), in, delay);
}


inline SimObject::ID::Packed SimNetwork::record(const SimObject::ID::Packed & obj, const port_t src_port, const SimObjectFactory &recFactory, const port_t rec_port )
{
    SimObject::ID obj_id(obj);
    SimObject::ID::Packed rec = create( recFactory, SimEngine::ID(obj_id.node, obj_id.eng) );
    connect(obj,0,rec,rec_port, Time::sec(0));
    return rec;
}


inline SimObject::ID::Packed SimNetwork::record( const SimObject::ID::Packed &obj, const SimObjectFactory &recFactory, const port_t rec_port )
{
    return record(obj,0,recFactory,rec_port);
}




inline SimObject::ID::Packed SimNetwork::record(const SimObject::ID::Packed & obj, const string field, const SimObjectFactory &recFactory, const port_t rec_port )
{
    SimObject::ID obj_id(obj);
    SimObject::ID::Packed rec = create( recFactory, SimEngine::ID(obj_id.node, obj_id.eng) );
    connect(obj,field,rec,rec_port, Time::sec(0));
    return rec;
}


inline void SimNetwork::set_dt(const Time &dt)
{
    if( _nSpikeMessages + _nAnalogMessages == 0 ) {
        _change_timestep_width_( simParam.dt, dt );
        reset();
        simParam.dt = dt;
    } else {
        // TODO: This needs to be inserted. However therefor some of the cppunit tests need to be fixed!
        // throw( PCSIM::ConstructionException( "SimNetwork::set_dt", "Time step width can not be changed after set up of connections." ) );
    }
}




inline Time SimNetwork::get_dt() const
{
    return simParam.dt;
}

template< class T >
inline bool SimNetwork::getObject( const SimObject::ID &id, T &p )
{
    p = dynamic_cast<T>( _getObject_( id ) );
    return ( p != NULL );
}

template< class T >
inline bool SimNetwork::getObject( const SimObject::ID::Packed &id, T &p )
{
    p = dynamic_cast<T>( _getObject_( SimObject::ID( id ) ) );
    return ( p != NULL );
}

inline SimObject *SimNetwork::object(const SimObject::ID::Packed &id)
{
    return _getObject_( *reinterpret_cast<const SimObject::ID*>(&id) );
}

inline SimObject *SimNetwork::object(const SimObject::ID &id)
{
    return _getObject_( id );
}

#endif

#endif /*SIMNETWORK_H_*/

---