Initial commit

Lts/Services/CentralEffectSimulation/dds_handler.cpp

@@ -0,0 +1,346 @@
+/**
+  * DdsHandlerAes for DDS
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by gr, SLSE, 2015-09-02
+  */
+
+#include "dds_handler.h"
+
+#include <DDS/Core/pacemaker.h>
+
+namespace CentralEffectSimulation
+{
+
+DdsHandler::DdsHandler(int domainId, int exerciseId)
+  : m_ddsConnector(std::make_shared<DDSConnector::DdsConnector>(domainId, IDL::PartitionType::Exercise, exerciseId))
+  , m_participantEventId(0)
+  , m_exerciseId(exerciseId)
+  , m_logger(getLogger("DdsHandler"))
+{
+  DEBUG_LOG(m_logger) << "DdsHandler(" << domainId << ") for partition: " << m_ddsConnector->getDefaultPartition();
+}
+
+bool DdsHandler::init(const QStringList &qosFileList)
+{
+  if (!m_ddsConnector->init(qosFileList))
+  {
+    ERROR_LOG(m_logger) << "Error initializing dds connections - aborting";
+    return false;
+  }
+
+  // default initialize Publisher and Subscriber
+  m_ddsConnector->initPublisherSubscriber();
+  m_ddsConnector->enableBatchedWriter(false);
+
+  // Pacemaker
+  m_pacemaker = std::make_shared<Core::Pacemaker>(m_ddsConnector);
+  m_topicLockMaster = std::make_shared<Core::TopicLockMaster>(m_ddsConnector);
+
+  m_dtcCore = Core::Interface::Dtc::create(m_ddsConnector);
+  m_dtcCore->enablePartitionTime();
+
+  m_dtsCes = CentralEffectSimulation::Interface::Dts::create(m_ddsConnector);
+  m_dtsCes->enableParticipantEvent();
+  m_dtsCes->enableBuildingOwnership();
+  m_dtsCes->enableSimulatedMovement();
+
+  m_ftsCes = CentralEffectSimulation::Interface::Fts::create(m_ddsConnector);
+  m_ftsCes->enableDetonationLocation();
+  m_ftsCes->enableSetOwnership();
+  m_ftsCes->enableSimulatedMovementModify();
+  m_ftsCes->enableSimulatedMovementRemove();
+  m_ftsCes->enableSimulatedMovementRemoveByParticipantId();
+
+  m_ftcTab = TrainingAreaBase::Interface::Ftc::create(m_ddsConnector);
+  if (!m_ftcTab->enableSendCesHit() ||
+      !m_ftcTab->enableSendCesHitInformation() ||
+      !m_ftcTab->enableSendGeopairingData() ||
+      !m_ftcTab->enableSendParticipantBlockedArea() ||
+      !m_ftcTab->enableSendParticipantBeStillWarning() ||
+      !m_ftcTab->enableDemandInit())
+  {
+    ERROR_LOG(m_logger) << "Could not enable SendCesHit";
+    return false;
+  }
+
+  m_ftcBld = Buildings::Interface::Ftc::create(m_ddsConnector);
+  if (!m_ftcBld->enableSendCesHitOnBuilding())
+  {
+    ERROR_LOG(m_logger) << "Could not enable SendCesHitOnBuilding";
+    return false;
+  }
+  if (!m_ftcBld->enableSendCesHit3DonBuilding())
+  {
+    ERROR_LOG(m_logger) << "Could not enable SendCesHit3DonBuilding";
+    return false;
+  }
+  if (!m_ftcBld->enableSetBuildingStates())
+  {
+    ERROR_LOG(m_logger) << "Could not enable SetBuildingStates";
+    return false;
+  }
+
+  // Subsribe for InfrastructureManagement::MainStructureElement
+  m_dtcIsm = InfrastructureManagement::Interface::Dtc::create(m_ddsConnector);
+  if (!m_dtcIsm->enableMainFootprint()        ||
+      !m_dtcIsm->enableMainStructureElement())
+  {
+    ERROR_LOG(m_logger) << "Could not enable ISM data topics";
+    return false;
+  } // if
+  m_dtcIsm->waitForHistoricalDataMainFootprint(20000);
+  m_dtcIsm->waitForHistoricalDataMainStructureElement(20000);
+
+  // Subsribe for AreaEffectSimulation::TriggeredExplosions
+  m_dtcAes = AreaEffectSimulation::Interface::Dtc::create(m_ddsConnector);
+
+  if (!m_dtcAes->enableTriggeredImpacts() ||
+      !m_dtcAes->enableExplosionSingle() ||
+      !m_dtcAes->enableExplosionArea() ||
+      !m_dtcAes->enableAesItemView() ||
+      !m_dtcAes->enableFunctionalArea() ||
+      !m_dtcAes->enableBorderline() ||
+      !m_dtcAes->enableNContamination() ||
+      !m_dtcAes->enableMineArea() ||
+      !m_dtcAes->enableDangerArea() ||
+      !m_dtcAes->enableDusSingleMine())
+  {
+    ERROR_LOG(m_logger) << "Could not initialize AES data topics";
+    return false;
+  }
+
+  DEBUG_LOG(m_logger) << "create FTC AES";
+  m_ftcAes = AreaEffectSimulation::Interface::Ftc::create(m_ddsConnector);
+  DEBUG_LOG(m_logger) << "init FTC AES";
+  if (!m_ftcAes->enableAll())
+  {
+    ERROR_LOG(m_logger) << "Could not initialize AreaEffectSimulation enableType function topic";
+    return false;
+  }
+
+  // Subsribe for ProjectDataManagement::ChargeType
+  m_dtcPdm = ProjectDataManagement::Interface::Dtc::create(m_ddsConnector);
+  m_dtcPdm->waitForHistoricalDataChargeType(2000);
+
+  if (!m_dtcPdm->enableChargeType())
+  {
+    ERROR_LOG(m_logger) << "Could not initialize ProjectDataManagement enableChargeType data topic client";
+    return false;
+  }
+
+  m_dtcPpm = ParticipantManagement::Interface::Dtc::create(m_ddsConnector);
+  if (!m_dtcPpm->enableDynamicParticipantData())
+  {
+    ERROR_LOG(m_logger) << "Could not initialize ParticipantManagement enableDynamicParticipantData data topic client";
+    return false;
+  }
+  if (!m_dtcPpm->enableParticipantPosition())
+  {
+    ERROR_LOG(m_logger) << "Could not initialize ParticipantManagement enableParticipantPosition data topic client";
+    return false;
+  }
+  if (!m_dtcPpm->enableParticipant())
+  {
+    ERROR_LOG(m_logger) << "Could not initialize ParticipantManagement enableParticipant data topic client";
+    return false;
+  }
+  if (!m_dtcPpm->enableType())
+  {
+    ERROR_LOG(m_logger) << "Could not initialize ParticipantManagement enableType data topic client";
+    return false;
+  }
+
+  DEBUG_LOG(m_logger) << "create FTC PPM";
+  m_ftcPpm = ParticipantManagement::Interface::Ftc::create(m_ddsConnector);
+  DEBUG_LOG(m_logger) << "init FTC PPM";
+  if (!m_ftcPpm->enableAll())
+  {
+    ERROR_LOG(m_logger) << "Could not initialize ParticipantManagement enableType function topic";
+    return false;
+  }
+
+  m_dtsTab = TrainingAreaBase::Interface::Dts::create(m_ddsConnector);
+  if (!m_dtsTab->enableEquipmentPosition())
+  {
+    ERROR_LOG(m_logger) << "Could not initialize TrainingAreaBase enableEquipmentPosition data topic server";
+    return false;
+  }
+  if (!m_ftcTab->enableSendParticipantBlockedArea())
+  {
+    ERROR_LOG(m_logger) << "Could not initialize TrainingAreaBase enableSendParticipantBlockedArea function";
+    return false;
+  }
+
+  m_dtcBld = Buildings::Interface::Dtc::create(m_ddsConnector);
+  if (!m_dtcBld->enableBuildingState())
+  {
+    ERROR_LOG(m_logger) << "Could not initialize Buildings data topic client";
+    return false;
+  }
+
+  m_dtcTab = TrainingAreaBase::Interface::Dtc::create(m_ddsConnector);
+  if (!m_dtcTab->enableGeopairingData())
+  {
+    ERROR_LOG(m_logger) << "Could not initialize TrainingAreaBase data topic client";
+    return false;
+  }
+
+  m_dtcMdm = MeteoDataManagement::Interface::Dtc::create(m_ddsConnector);
+  if (!m_dtcMdm->enableMeteoData())
+  {
+    ERROR_LOG(m_logger) << "Could not initialize MeteoData data topic client";
+    return false;
+  }
+
+
+  // for Elevation :
+  m_asmDtc = AssetManagement::Interface::Dtc::create(m_ddsConnector);
+  m_asmDtc->waitForHistoricalDataTrainingArea(1000);
+  m_exmDtc = ExerciseManagement::Interface::Dtc::create(m_ddsConnector);
+  m_exmDtc->waitForHistoricalDataExercise(1000);
+  // : for Elevation
+
+  return true;
+} // end of init
+//-----------------------------------------------------------------------------
+
+qint64 DdsHandler::currentPartitionTime() const
+{
+  return m_dtcCore->partitionTime().timeStamp();
+}
+
+int DdsHandler::participantId2EquipNo(const int participantId) const
+{
+   return m_dtcPpm->equipmentNumberByParticipantId(participantId);
+} // end of participantId2EquipNo()
+
+int DdsHandler::equipNo2ParticipantId(const int equipmentNumber) const
+{
+    return m_dtcPpm->participantIdByEquipmentNumber(equipmentNumber);
+}
+
+//-----------------------------------------------------------------------------
+// ///////////////////////////////////
+// P D M (ProjectDataManagement)
+// ///////////////////////////////////
+double DdsHandler::chargeTypeRadius(const AreaEffectSimulation::ChargeStruct &chargeStruct)
+{
+  const double radius = m_dtcPdm->impactRadius(chargeStruct.chargeTypeId(), chargeStruct.igniterTypeId(), chargeStruct.igniterFunctionId());
+  DEBUG_LOG(m_logger) << "chargeTypeRadius = " << radius;
+  return radius;
+} // getRadiusOfMunition
+
+double DdsHandler::chargeHeight(const AreaEffectSimulation::ChargeStruct &chargeStruct)
+{
+  const double height = m_dtcPdm->height(chargeStruct.chargeTypeId(), chargeStruct.igniterTypeId(), chargeStruct.igniterFunctionId());
+  DEBUG_LOG(m_logger) << "chargeHeight = " << height;
+  return height;
+}
+
+bool DdsHandler::isSmartChargeType(const AreaEffectSimulation::ChargeStruct &chargeStruct)
+{
+  const bool isSmart = m_dtcPdm->isSmart(chargeStruct.chargeTypeId(), chargeStruct.igniterTypeId(), chargeStruct.igniterFunctionId());
+  DEBUG_LOG(m_logger) << "isSmartChargeType = " << isSmart;
+  return isSmart;
+} // isSmartType
+
+bool DdsHandler::isSmoke(const AreaEffectSimulation::ChargeStruct &chargeStruct)
+{
+  const bool isSmoke = m_dtcPdm->isSmoke(chargeStruct.chargeTypeId(), chargeStruct.igniterTypeId(), chargeStruct.igniterFunctionId());
+  DEBUG_LOG(m_logger) << "isSmoke = " << isSmoke;
+  return isSmoke;
+} // isSmoke
+
+bool DdsHandler::isLaserGuidable(const AreaEffectSimulation::ChargeStruct &chargeStruct)
+{
+  const bool isLaserGuidable = m_dtcPdm->isLaserGuidable(chargeStruct.chargeTypeId(), chargeStruct.igniterTypeId(), chargeStruct.igniterFunctionId());
+  DEBUG_LOG(m_logger) << "isLaserGuidable = " << isLaserGuidable;
+  return isLaserGuidable;
+}
+
+bool DdsHandler::isJamming(const AreaEffectSimulation::ChargeStruct &chargeStruct)
+{
+  const bool isJamming = m_dtcPdm->isJamming(chargeStruct.chargeTypeId(), chargeStruct.igniterTypeId(), chargeStruct.igniterFunctionId());
+  DEBUG_LOG(m_logger) << "isJamming = " << isJamming;
+  return isJamming;
+}
+
+bool DdsHandler::isDus(const AreaEffectSimulation::ChargeStruct &chargeStruct)
+{
+  const bool isDus = m_dtcPdm->mineClass(chargeStruct.chargeTypeId(), chargeStruct.igniterTypeId(), chargeStruct.igniterFunctionId())== AreaEffectSimulation::MineClass::Concrete;
+  DEBUG_LOG(m_logger) << "isDus = " << isDus;
+  return isDus;
+}
+
+bool DdsHandler::isAtMine(const AreaEffectSimulation::ChargeStruct &chargeStruct)
+{
+  const bool isAtMine = m_dtcPdm->isAtMine(chargeStruct.chargeTypeId(), chargeStruct.igniterTypeId(), chargeStruct.igniterFunctionId());
+  DEBUG_LOG(m_logger) << "isAtMine = " << isAtMine;
+  return isAtMine;
+}
+
+ProjectDataManagement::VolatilityType DdsHandler::volatilityTypeId(const AreaEffectSimulation::ChargeStruct &chargeStruct)
+{
+  const ProjectDataManagement::VolatilityType volatilityType= m_dtcPdm->volatilityTypeId(chargeStruct.chargeTypeId(),
+                                                                                         chargeStruct.igniterTypeId(),
+                                                                                         chargeStruct.igniterFunctionId());
+  DEBUG_LOG(m_logger) << "volatilityType=" << volatilityType;
+  return volatilityType;
+}
+
+int DdsHandler::remainingTasCode(const AreaEffectSimulation::ChargeStruct &chargeStruct) const
+{
+  return m_dtcPdm->remainingTasCode(chargeStruct.chargeTypeId(), chargeStruct.igniterTypeId(), chargeStruct.igniterFunctionId());
+}
+
+int DdsHandler::secondaryRemainingTasCode(const AreaEffectSimulation::ChargeStruct &chargeStruct) const
+{
+  return m_dtcPdm->secondaryRemainingTasCode(chargeStruct.chargeTypeId(), chargeStruct.igniterTypeId(), chargeStruct.igniterFunctionId());
+}
+
+int DdsHandler::getLethalRadius(const AreaEffectSimulation::ChargeStruct &chargeStruct) const
+{
+  return m_dtcPdm->getLethalRadius(chargeStruct.chargeTypeId(), chargeStruct.igniterTypeId(), chargeStruct.igniterFunctionId());
+}
+
+int DdsHandler::getNonLethalRadius(const AreaEffectSimulation::ChargeStruct &chargeStruct) const
+{
+  return m_dtcPdm->getNonLethalRadius(chargeStruct.chargeTypeId(), chargeStruct.igniterTypeId(), chargeStruct.igniterFunctionId());
+}
+
+int DdsHandler::getHazardDistance(const AreaEffectSimulation::ChargeStruct &chargeStruct) const
+{
+  return m_dtcPdm->hazardDistance(chargeStruct.chargeTypeId(), chargeStruct.igniterTypeId(), chargeStruct.igniterFunctionId());
+}
+
+ProjectDataManagement::IgniterFunctionBase DdsHandler::getIgniterFunctionBaseFromChargeTypeId(int chargeTypeId, int igniterTypeId, int igniterFunctionId)
+{
+  return m_dtcPdm->getChargeTypeIgniterTypeIgniterFunction(chargeTypeId, igniterTypeId, igniterFunctionId).igniterFunctionBaseId();
+}
+
+QVector<ProjectDataManagement::CasEffect> DdsHandler::getCasEffects(const AreaEffectSimulation::ChargeStruct &chargeStruct)
+{
+  return m_dtcPdm->casEffects(chargeStruct.chargeTypeId(), chargeStruct.igniterTypeId(), chargeStruct.igniterFunctionId());
+}
+
+
+int32_t DdsHandler::getLegacyIdFromChargeTypeId(const AreaEffectSimulation::ChargeStruct &chargeStruct)
+{
+  int32_t legacyId = 0;
+  legacyId = m_dtcPdm->getChargeTypeIgniterTypeIgniterFunction(chargeStruct.chargeTypeId(), chargeStruct.igniterTypeId(), chargeStruct.igniterFunctionId()).chargeLegacyId();
+  DEBUG_LOG(m_logger) << "legacyId = " << legacyId;
+  return legacyId;
+}
+
+int DdsHandler::searchRadius(const AreaEffectSimulation::ChargeStruct &chargeStruct)
+{
+  const int searchRadius = m_dtcPdm->searchRadius(chargeStruct.chargeTypeId(), chargeStruct.igniterTypeId(), chargeStruct.igniterFunctionId());
+  DEBUG_LOG(m_logger) << "searchRadius = " << searchRadius;
+  return searchRadius;
+} // searchRadius
+
+
+
+} // Namespace CentralEffectSimulation