DistributedAnalogMessageDispatcher.cpp

Go to the documentation of this file.

#include "DistributedAnalogMessageDispatcher.h"

DistributedAnalogMessageDispatcher::DistributedAnalogMessageDispatcher(int numNodes,
        int minimumDelay,
        vector< DistributedIncomingAnalogMsgDispatcher* > & incomingDispatchers,
        vector< DistributedOutgoingAnalogMsgDispatcher*> & outgoingDispatchers,
        AnalogMessageDispatcher &localDispatcher)
        : nNodes(numNodes), minDelay(minimumDelay),
        incoming_dispatchers(incomingDispatchers),
        outgoing_dispatchers(outgoingDispatchers),
        local_dispatcher(localDispatcher), currentStep(0)
{}

DistributedAnalogMessageDispatcher::~DistributedAnalogMessageDispatcher()
{}


void DistributedAnalogMessageDispatcher::dispatchOutgoingAnalogMsgs()
{
    vector<DistributedOutgoingAnalogMsgDispatcher *>::const_iterator it;
    for (it = outgoing_dispatchers.begin(); it != outgoing_dispatchers.end(); ++it)
        (*it)->dispatchMPIOutgoingAnalogMsgs(currentStep);
}


void DistributedAnalogMessageDispatcher::dispatchIncomingAnalogMsgs(int step)
{
    /* vector<DistributedIncomingAnalogMsgDispatcher>::const_iterator it;
       for (it = incoming_dispatchers.begin(); it != incoming_dispatchers.end(); ++it)
          it->dispatchIncomingAnalogMsgs(currentStep); */
}

void DistributedAnalogMessageDispatcher::dispatchDelayerCycledIncomingAnalogMsgs()
{
    vector<DistributedIncomingAnalogMsgDispatcher*>::const_iterator it;
    for (it = incoming_dispatchers.begin(); it != incoming_dispatchers.end(); ++it)
        (*it)->dispatchDelayerCycledIncomingAnalogMsgs();

    // this method is invoked after mpi exchange so we reset the current step within a cycle
    currentStep = 0;
}

void DistributedAnalogMessageDispatcher::dispatchAnalogMsgs()
{
        dispatchOutgoingAnalogMsgs();
    // dispatchIncomingAnalogMsgs(currentStep);
    cycledLocalDispatcher.dispatchIncomingAnalogMsgs(currentStep);
    local_dispatcher.dispatchAnalogMsgs();
    currentStep++;
}

void DistributedAnalogMessageDispatcher::initialize()
{
    vector<DistributedIncomingAnalogMsgDispatcher *>::const_iterator in_it;
    for (in_it = incoming_dispatchers.begin(); in_it != incoming_dispatchers.end(); ++in_it) 
        (*in_it)->initialize();
            
    vector<DistributedOutgoingAnalogMsgDispatcher *>::const_iterator out_it;
    for (out_it = outgoing_dispatchers.begin(); out_it != outgoing_dispatchers.end(); ++out_it)
        (*out_it)->initialize();
    cycledLocalDispatcher.initialize();
    
}

void DistributedAnalogMessageDispatcher::reset(double dt)
{
        vector<DistributedIncomingAnalogMsgDispatcher *>::const_iterator in_it;
    for (in_it = incoming_dispatchers.begin(); in_it != incoming_dispatchers.end(); ++in_it) 
        (*in_it)->reset(dt);    
        local_dispatcher.reset(dt);        
    currentStep = 0;    
}

---