DtMetricCollector

metricCollector.h

#pragma once

#include <iostream>
#include <fstream>

class DtCgf;
class DtScenario;
class DtLocalObject;
class DtRwSensorContactInfo;

// Class which collects metrics on particular objects.
class DtMetricCollector
{
public:
   DtMetricCollector(DtCgf* cgf);

   virtual ~DtMetricCollector();

   // A tick callback is installed with the main VRF system to get called each
   // simulation tick and check the metrics.
   static void tickCallback(void* usr);
   virtual void tick();

   // Callbacks to manage scenario start/end conditions.
   // The metrics output file is restarted each time a scenario is started.
   static void postLoadCallback(const DtScenario& scenario, void* usr);
   virtual void processLoad(const DtScenario& scenario);
   static void preCloseCallback(void* usr);
   virtual void processClose();
   static void postRollbackCallback(void* usr);
   virtual void processRollback();

   virtual void printLocationAndContacts(const DtLocalObject* entity);
   virtual void printContact(const DtRwSensorContactInfo* contact);

protected:
   DtCgf* myCgf;
   std::ofstream myOutputFile;
   double myLastMetricTime;


};

metricCollector.cxx

#include "metricCollector.h"
#include "vrfcgf/cgf.h"
#include <iostream>
#include <fstream>
#include "vrfcore/simulationServices.h"
#include "vrfobjcore/simObject.h"
#include "vrfobjcore/vrfObjectStateRepository.h"
#include "vrfobjcore/localObjectManager.h"
#include "vrfutil/sensorContactInfoList.h"
#include "vrfutil/rwSensorContactInfo.h"
#include <vrfutil/profiler.h>

const double theMetricPeriod = 0.5;

DtMetricCollector::DtMetricCollector(DtCgf* cgf)
: myCgf(cgf)
, myLastMetricTime(0)
{
   // Register callbacks for notification of scenario load and close.
   // Note:  New scenario is also invokes the scenario load callback.
   cgf->addPostLoadScenarioCallback(postLoadCallback, this);
   cgf->addPreCloseScenarioCallback(preCloseCallback, this);
   cgf->addPostScenarioRollbackCallback(postRollbackCallback, this);
}

DtMetricCollector::~DtMetricCollector()
{

}

void DtMetricCollector::postLoadCallback(const DtScenario& scenario, void* usr)
{
   static_cast<DtMetricCollector*>(usr)->processLoad(scenario);
}

void DtMetricCollector::processLoad(const DtScenario& scenario)
{
   myCgf->addPostTickCallback(tickCallback, this);
   DtString filename("metrics.txt");

   if (!myOutputFile.is_open()) // prevent reopening on rewind/rollback
   {
      myOutputFile.open(filename);

      if (!myOutputFile.good())
      {
         DtWarn << "Could not open metrics file for output " << filename << std::endl;
      }
   }
}

void DtMetricCollector::preCloseCallback(void* usr)
{
   static_cast<DtMetricCollector*>(usr)->processClose();
}

void DtMetricCollector::processClose()
{
   myCgf->removePostTickCallback(tickCallback, this);
   myOutputFile.close();
   myLastMetricTime = 0;
}

void DtMetricCollector::postRollbackCallback(void* usr)
{
   static_cast<DtMetricCollector*>(usr)->processRollback();
}

void DtMetricCollector::processRollback()
{
   myLastMetricTime = myCgf->simulationServices()->simTime();
}

void DtMetricCollector::tickCallback(void* usr)
{
   static_cast<DtMetricCollector*>(usr)->tick();
}

void DtMetricCollector::tick()
{
   DtPROFILE("DtMetricCollector::tick");
   // Check for the paused state, and don't do any metrics if paused.
   if (myCgf->simulationServices()->dT() > 0)
   {
      // Only record metrics if enough time has passed since the last time the metrics were recorded.
      if (myCgf->simulationServices()->simTime() >= myLastMetricTime + theMetricPeriod)
      {
         myLastMetricTime = myCgf->simulationServices()->simTime();
         myOutputFile << "Time: " << myLastMetricTime << "\n";

         // Only collect metrics on particular objects.
         // In this case, just check for an entity named "R 1"
         DtLocalObject* obj = myCgf->localObjectManager()->lookup(DtUUID("R 1"));
         if (obj)
         {
            printLocationAndContacts(obj);
         }
      }
   }
}

void DtMetricCollector::printLocationAndContacts(const DtLocalObject* entity)
{
   // Output basic information on the object such as name and location.
   myOutputFile << entity->objectName() << "\n";
   DtGeodeticCoord geodLoc;
   geodLoc.setGeocentric(entity->worldPosition());
   myOutputFile << "\tLocation: " << geodLoc.string() << "\n";

   // If the entity has any sensor contacts, show those as well.
   DtListItem* item = entity->internalState()->objectContactList().first();
   if (item)
   {
      myOutputFile << "\tContacts: ";
      for (; item; item = item->next())
      {
         const DtRwSensorContactInfo* contactInfo = static_cast<const DtRwSensorContactInfo*>(item->data());
         printContact(contactInfo);
      }
      myOutputFile << "\n";
   }
}

void DtMetricCollector::printContact(const DtRwSensorContactInfo* contact)
{
   // For each contact, find the object name.
   DtSimObjectReference obj = myCgf->simulationServices()->simObjectManager()->lookup(contact->contact());

   if (obj.isValid())
   {
      myOutputFile << obj->objectName() << " ";
   }
}