multiVehicleFed.h

Go to the documentation of this file.

/*******************************************************************************
 ** Copyright (c) 2014 MAK Technologies, Inc
 ** All rights reserved.
 *******************************************************************************/

#pragma once

#include <vlutil/vlPerformanceStats.h>
#include <vl/parallelExecutionContainer.h>
#include <vl/publisherContainer.h>
#include <vl/detonationInteraction.h>
#include "vehicleSim.h"

class DtF18Initializer;
class DtReflectedEntityList;
class DtExerciseConn;


class DtMultiVehicleFed
{
public:

   // User parallel execution, or serial execution
   enum mode { PARALLEL=1, SERIAL=2 };

   DtMultiVehicleFed();

   virtual ~DtMultiVehicleFed();

   DtExerciseConn* exerciseConn() { return myExConn;  }

   // Set up and initialize for an exercise
   void initializeExConn(DtTime theTimeOutInterval, DtF18Initializer *initializer);

   // initialize the fleet
   void initializeFleet(int appNumOffset, int theNumVehicles, const DtF18Initializer *initializer);

   // Process inputs up to maximum elapsed real time
   void drainInput(double tMaxRealElapsed);

   // Set/get the simulation time
   void setSimTime(double time);
   double simTime() const;

   // Get the number of remote entities
   int numberRemoteEntities() const;

   // Simulate all vehicles
   void simulate();

   // Publish all vehicle outputs
   void publish();

   // Sleep until real time catches up to simulated time
   double sleep(double deltaTime);

   // Dismantle the fleet
   void dismantleFleet();

   // Dismantle an exercise
   void dismantleExConn();

   // Execution mode
   void setExecutionMode(mode theMode);
   mode executionMode() const;

protected:

   // Factory to create and initialize a single fleet vehicle.
   DtVehicleSim *vehicleFactory(int num, int appNumOffset, 
      const DtF18Initializer *initializer, DtObjectPublisherContainer& pubContainer);

   DtString& getVehicleName(int num, const DtString& baseName, DtString& name);

   // Detonation callback handler
   static void theDetonationCb(DtDetonationInteraction *theDetonation, void *theUserData);

   // Process detonation over all vehicles in parallel
   void processDetonation(const DtDetonationInteraction *theDetonation);

private:
   mode     myMode;     // Whether to execute in parallel or serial
   DtTime   mySimTime;  // Simulated time
   DtClock *myClock;    // Exercise clock

   // Exercise connection for this simulation
   DtExerciseConn *myExConn;

   // Reflected entity list, tracks entities published by remote simulations
   DtReflectedEntityList *myRel;

   // Container for fleet (all vehicles published by this simulation)
   // This shows how to use the general parallel execution container.
   DtParallelExecutionContainer<DtVehicleSim> mySimulatedVehicles;

   // Container of published objects.
   // This shows how to publish objects in parallel, simpler than DtParallelExecutionContainer.
   DtObjectPublisherContainer myPublishedObjects;
};