lifemaps/qt5-legatus-legacy
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
3028302f7b9446e68264543dd5499227c85305b7
qt5-legatus-legacy/Lts/Services/AreaEffectSimulation/object_explosion_cluster.cpp
T
torsten b7d90b9afe Initial commit
2026-08-13 18:33:10 +02:00

3028 lines
133 KiB
C++
Executable File
Raw Blame History

/**
* @RDE_HEADER@
* ObjectMap for ExplosionCluster
* $Id$
* $HeadURL$
* $Author$
*/
#include "object_explosion_cluster.h"
#include "Utils/polygons.h"
#include "handler_charge_administration.h"
#include "handler_trajectory.h"
#include "special_area_provider.h"
#include <LtsCoordTrans/lts_coord_trans.h>
#include <LtsUtilsCore/dds_bitarray.h>
#include <Trajectory/trajectory_generator.h>
#include <Trajectory/trajectory_generator_vulcano.h>
#include <Trajectory/trajectory_helper.h>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonValue>
#include <QPolygonF>
#include <QTimer>
#include <QVector3D>
/*
* Typen von ExplosionCluster: (Stand 24.05.2024)
*
Typ | participantId Flugkurve(n) Target Streuung
--------------------------------------------------------------------------------
Normal | ja ja ja ja
Vulcano | ja ja ja ja
--------------------------------------------------------------------------------
HLA | nein (-1) nein ja nein == light
--------------------------------------------------------------------------------
NASAT | ja reduziert ja ?ja? == light+
?? Vulcano?? | ? ? ? ?
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
OC |
--------------------------------------------------------------------------------
*/
/*
* possible Annotations: 2024-02-23
*
Incomplete UserInput:
reason = QString(QStringLiteral("firingParticipantId is invalid (%1)")).arg(firingParticipantId);
reason = QString(QStringLiteral("firingParticipantId not found (%1)")).arg(firingParticipantId);
reason = QString(QStringLiteral("firingParticipantId '%1' has invalid position (NaN)")).arg(firingParticipantId);
reason = QString(QStringLiteral("firingParticipantId '%1' has invalid position (0,0)")).arg(firingParticipantId);
*reasonOut = QStringLiteral("originatorOrigin isNaN");
*reasonOut = QStringLiteral("originatorOrigin isNull");
Logical error:
reason = QString(QStringLiteral("Not enough time for estimated flight duration (timeUntilFireMSec=%1).")).arg(timeUntilFireMSec);
Internal Error:
*reasonOut = QStringLiteral("no MaxFlightDuration");
reason = QString(QStringLiteral("GenerateGunToTargetLine (%1)")).arg(reasonGtlOut);
reason = QString(QStringLiteral("(flightDurationSecError (%1;%2))")).arg(tdRef.flightDurationMSec).arg(reasonTraj);
reason = QString(QStringLiteral("(peakHeightAbs outOfRange (%1))")).arg(reasonTraj);
reason += QString(QStringLiteral("(elevation_angle_degree outOfRange (%1))")).arg(elevation_angle_degree);
reason += QStringLiteral("(generateTrajectory failed)");
Trajectory:
*reasonOut = QString(QStringLiteral("HeightElevationError(%1 %2 %3)")).arg(posStart.z()).arg(heightAbs).arg(posEnd.z());
*reasonOut = QString(QStringLiteral("StartEndDistanceError(%1)")).arg(r);
*reasonOut = QString(QStringLiteral("flightDurationSecErrorUnknown(%1)")).arg(result);
*reasonOut = QString(QStringLiteral("45DegreeShot(%1)")).arg(arcSin);
*
*/
// See E01562-191 Anpassung Trajektorien (Von Explosion Cluster zu Effect Cluster)
#define USE_TRAJECTORY_VIA_HANDLER
#define DUMP() dump(__FILE__, __LINE__)
// ToDo: mark the end of aes enum and update following (check Endemarke)
static_assert((int)AreaEffectSimulation::AesType_def::AtExplosionClusterGunToTargetLine < 100, "id may overlap at runtime");
// Aufteilung der ids:
// ExplosionCluster ddsData(m_data.id,
// aiv.id (1000 * m_data.id + AesType::AtExplosionCluster);
// aiv2.id (1000 * m_data.id + AesType::AtExplosionClusterSingleExplosions);
// aiv3.id (1000 * m_data.id + AesType::AtExplosionClusterGunToTargetLine);
// trajectoryTimeAwareRef.id(1000 * m_data.id + 100 + explosionIndex);
// ^^^ um Platz zu lassen fuer AesType::At...
// trajectoryTimeAwareRef.id(1000 * 1 + 100 + 0); == 1100
// trajectoryTimeAwareRef.id(1000 * 1 + 100 + 899); == 1999
// trajectoryTimeAwareRef.id(1000 * 2 + 100 + 0); == 1200
// Note: const int explosionIndex = explosionNumber-1;
// Effects (Impacts)
// m_effects.id (1000 * m_data.id + AesType::AtExplosionClusterSingleExplosions)
/* Ablauf
*
createObject
- setupFiringOrigin
- checkPreConditionsComplete
- firingOriginIsValid
- initialCalculations
- calculate the subAreas / mtps
- estimate max FlightDuration:
- checkPreConditions (configuring preStartTimer)
*/
using DetonationLocationRequest = CentralEffectSimulation::DetonationLocationRequest;
using DetonationLocationReply = CentralEffectSimulation::DetonationLocationReply;
//
// AreaEffectSimulation
//
namespace AreaEffectSimulation
{
Core::FunctionReplyObject createAnnotationObject(int id, const QString &reason)
{
//: "Anmerkung:"
return Core::FunctionReplyObject(id, tr_lts("dds", "Annotation: '%1' (id=%2).")).arg(reason).arg(id);
}
Core::FunctionReplyObject createAnnotationObjectError(int id, const QString &reason)
{
//: "Fehler:"
return Core::FunctionReplyObject(id, tr_lts("dds", "Error: '%1' (id=%2).")).arg(reason).arg(id);
}
Core::FunctionReplyObject createAnnotationObjectIncomplete(int id, const QString &reason)
{
//: "Unvollstaendig:"
return Core::FunctionReplyObject(id, tr_lts("dds", "Incomplete: '%1' (id=%2).")).arg(reason).arg(id);
}
ObjectExplosionCluster::ObjectExplosionCluster(MainHandler *mainHandler, QObject *parent)
: ObjectBaseTmpl(mainHandler, QStringLiteral("ExplosionCluster"), parent)
, m_singleExplosionTriggerTimer(new QTimer(this))
, m_preStartTimer(new QTimer(this))
, m_lastSentTriggeredExplosionNumber(-1)
, m_chargeCountUntilLastStart(0)
, m_explosionIndex(0)
{
// connect(m_singleExplosionTriggerTimer, &QTimer::timeout,
// this, &ObjectExplosionCluster::checkNextSingleExplosion);
connect(m_preStartTimer, &QTimer::timeout, this, &ObjectExplosionCluster::checkNextFire);
m_bSupportsPausing = true;
}
ObjectExplosionCluster::~ObjectExplosionCluster() { removeTopics(); }
bool ObjectExplosionCluster::isOnlyObjectNameModifiable() const
{
const bool bBaseIsOnlyNameModifiable = ObjectBase::isOnlyObjectNameModifiable();
const qint64 nowMsec = partitionTimeMSec();
const qint64 activationMsec = activationTime().toMSecsSinceEpoch();
qint64 preStartMsec = activationMsec - m_temporaryData.estimatedMaxFlightDurationMSec; // estimatedMaxFligh contains a buffer time (10% + 2sec)
const bool bReached = nowMsec >= preStartMsec;
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << ", bBaseIsOnlyNameModifiable=" << bBaseIsOnlyNameModifiable
<< ", m_estimatedMaxFlightDurationMSec=" << m_temporaryData.estimatedMaxFlightDurationMSec << ", nowMsec=" << nowMsec
<< ", activationMsec=" << activationMsec << ", prePreStartMsec=" << preStartMsec << ", leftMsec=" << (preStartMsec - nowMsec)
<< ", bReached=" << bReached << ", m_temporaryData.isObjectModifiable=" << m_temporaryData.isObjectModifiable;
return bBaseIsOnlyNameModifiable || !m_temporaryData.isObjectModifiable;
}
bool ObjectExplosionCluster::isObjectModifiable() const
{
return ObjectBase::isObjectModifiable(); // ToDo: check: && m_temporaryData.isObjectModifiable
}
bool ObjectExplosionCluster::isFiringTimeReached() const
{
return isActivationTimeSet() && partitionTime().toMSecsSinceEpoch() >= activationTime().toMSecsSinceEpoch() - flightDurationMsec();
}
Core::FunctionReplyObject ObjectExplosionCluster::createObject(const Database::AesExplosionCluster &data)
{
Core::FunctionReplyObject ret;
// some plausibility checks
ret = checkObjectData(data);
if (ret.error())
return ret;
if (data.impactCount > AreaEffectSimulation::s_maxTrajectoriesPerExplosionCluster)
return Core::FunctionReplyObject(data.id, tr_lts("dds", "Error with explosion cluster with id %1, impactCount exceeds limit.")).arg(m_data.id);
const bool bFromOpwUser = data.id == 0;
// No need to create object, if there is not enough charge left.
// HLA Interface is using externalId...
// external (externalId>0) -> no claim required
// external (externalId==0) -> claim required
// NASAT: AirSupport -> no claim required
const bool bDoClaimPlannedCharge
= (data.id == 0) && (data.externalId <= 0) && (m_mainHandler->gearClassOfChargeTypeId(data.chargeTypeId) != ProjectDataManagement::GearClass_def::AirSupport);
if (bDoClaimPlannedCharge) // new, not read from db
ret = m_mainHandler->chargeAdministrationHandler()->claimPlannedCharge(data.chargeTypeId, data.partyId, data.impactCount);
if (ret.error())
return ret;
// GUEZE-2675
// ExplosionClusters created via HLA have to be always central
// so every ExplosionCluster with an external id set (> 0), is handled central
ret = ObjectBaseTmpl::createObject(data, false, data.externalId > 0);
if (ret.error())
{
if (bDoClaimPlannedCharge)
m_mainHandler->chargeAdministrationHandler()->claimPlannedCharge(data.chargeTypeId, data.partyId, (-1) * data.impactCount);
return ret;
}
// If an explosionCluster is EsPrepared (EffectStart set), maybe the calculations
// to generate trajectories etc are already done.
// And the corresponding topics are most likely already published.
// SvcAes could be restarted _after_ calculations and before effectStart (maybe also during effectDuration)
// The initialCaculation fails due to not enough time for the ammo to fly.
// In that case, the ExplosionCluster is marked invalid.
// But if the user re-enables the ExplosionCluster impacts or trajectories
// from former calculations are _accidentally_ considered and displayed.
// To avoid that situation:
removeTopics();
// keep in mind: if no participantId is provided: no gunToTargetLine will be calculated
if (isMhpRotationProvided())
m_temporaryData.calculatedMhpRotationNorthDeg = m_data.mhpRotationRequest;
// setupFiringOrigin
if (bFromOpwUser && isOriginatorParticipantIdProvided())
{
Core::FunctionReplyObject retSFO = setupFiringOrigin();
m_temporaryData.annotationString = retSFO.translated().toStdString();
if (!isExplosionClusterMarkedValid())
m_data.effectStart = QDateTime();
}
// checkPreConditions :
// if not valid, annotationString and effectStart will be modified AFTER ObjectBaseTmpl::createObject
// But the publishData will be executed via m_publishDataTimer and therefore
// after our checkPreConditions-update :-)
{
Core::FunctionReplyObject retCPC = checkPreConditionsComplete();
m_temporaryData.annotationString = retCPC.translated().toStdString();
if (!isExplosionClusterMarkedValid())
m_data.effectStart = QDateTime();
}
// : checkPreConditions
if (data.id <= 0) // new, not read from db
{
m_data.originalEffectDuration = data.effectDuration;
m_data.originalEffectStart = data.effectStart;
}
// Do not continue running areas on restart of svcAes:
// else
// checkNextSingleExplosion();
DUMP();
return ret;
}
// [GUEZE-2952] Schutzwirkung der Gebaeude spaeter berechnen
//
// First, the DetonationLocationReply is extended by the building ID.
// The building status is subscribed to in AES ObjectExplosionCluster
// and the BuildingId is added to TracjectoryData.
// When a building reaches 80% destruction, the intersection of the trajectory with a building is determined again
// and the trajectory is updated on the DDS bus.
// Folgendes connect an geeigneter Stelle einbauen (Aktivieren und dekativieren.
// connect(m_mainHandler->dds()->bldDtc().get(), &Buildings::Interface::Dtc::buildingStateChanged,
// this, &ObjectExplosionCluster::onBuildingStateChanged);
// void ObjectExplosionCluster::onBuildingStateChanged(const Buildings::BuildingState &data, DataModification modType)
// {
// if (modType != DataModification::eModified)
// return;
// if (data.damagePercent() < 80 )
// return;
// DEBUG_LOG(m_logger) << "data.damagePercent() > 80. Check, if m_trajectoryCont contains building:" << data.id()
// << " aesItemId=" << m_aiv.aesItemId();
// for (const TracjectoryData &tracjectoryData : qAsConst(m_trajectoryCont))
// {
// DEBUG_LOG(m_logger) << "print_m_trajectory"
// << " value: index=" << tracjectoryData.index
// << " buildingId=" << tracjectoryData.buildingId;
// if (tracjectoryData.buildingId == data.id())
// {
// DEBUG_LOG(m_logger) << "Update trajectory id=" << tracjectoryData.index;
// QString reason;
// bool startDetonationLocationRequest = true;
// generateTrajectory(tracjectoryData.index, startDetonationLocationRequest, &reason);
// }
// } // for
// }
Core::FunctionReplyObject ObjectExplosionCluster::updateObject(const Database::AesExplosionCluster &data)
{
DEBUG_LOG(m_logger) << "updateObject properties=" << data.properties;
Core::FunctionReplyObject ret;
// some plausibility checks
ret = checkObjectData(data);
if (ret.error())
return ret;
if (data.impactCount > AreaEffectSimulation::s_maxTrajectoriesPerExplosionCluster)
return Core::FunctionReplyObject(data.id, tr_lts("dds", "Error with explosion cluster with id %1, impactCount exceeds limit.")).arg(m_data.id);
ret = ObjectBaseTmpl::updateObject(data);
if (ret.error() || (isOnlyObjectNameModifiable() && (data.id > 0))) // data.id > 0 -> negative values from oc always get a full update
return ret;
// if (data.id == 0) // should not happen, maybe an assert here ?
// return ret;
// only allow some fields
Database::AesExplosionCluster tmpData(m_data);
tmpData.id = std::abs(data.id);
tmpData.name = data.name;
tmpData.element = data.element;
tmpData.effectStart = data.effectStart;
tmpData.effectDuration = data.effectDuration;
tmpData.zog = data.zog;
tmpData.explosionGeometryId = data.explosionGeometryId;
tmpData.impactPosition = data.impactPosition;
tmpData.rotationAngle = data.rotationAngle;
tmpData.impactWidth = data.impactWidth;
tmpData.impactLength = data.impactLength;
tmpData.impactCount = data.impactCount;
tmpData.mhpCountRequest = data.mhpCountRequest;
tmpData.igniterTypeId = data.igniterTypeId;
tmpData.igniterFunctionId = data.igniterFunctionId;
tmpData.peakHeight = data.peakHeight;
tmpData.flightDuration = data.flightDuration;
tmpData.partyId = data.partyId;
tmpData.participantId = data.participantId;
tmpData.firingCenterPosition = data.firingCenterPosition;
tmpData.chargeTypeId = data.chargeTypeId;
tmpData.fireRequestTime = data.fireRequestTime;
tmpData.altitude = data.altitude;
tmpData.firePurpose = data.firePurpose;
// [GUEZE-3145] Automatische Veraenderung bei Steilfeuer Dialog -> Stoeren
tmpData.firePurposeId = data.firePurposeId;
tmpData.effectMarkingInTa = data.effectMarkingInTa;
tmpData.effectStateId = data.effectStateId; // overwrite for oc
tmpData.properties = data.properties;
if (!isOnlyObjectNameModifiable()) // check again, this time also if oc
{
tmpData.originalEffectDuration = data.effectDuration;
tmpData.originalEffectStart = data.effectStart;
tmpData.impactCount = data.impactCount;
tmpData.mhpCountRequest = data.mhpCountRequest;
tmpData.mhpRotationRequest = data.mhpRotationRequest;
}
tmpData.launchVelocity = data.launchVelocity;
tmpData.launchAngleDeg = data.launchAngleDeg;
tmpData.dropAngle = data.dropAngle;
tmpData.tapTimepoint = data.tapTimepoint;
tmpData.lcPrf = data.lcPrf;
tmpData.lcTermination = data.lcTermination;
tmpData.cloudBase = data.cloudBase;
if (!m_mainHandler->db()->update(tmpData))
{
return Core::FunctionReplyObject(data.id, tr_lts("dds", "Error updating explosion cluster with id %1 in database.")).arg(m_data.id);
}
if ((data.externalId <= 0) && m_mainHandler->gearClassOfChargeTypeId(m_data.chargeTypeId) != ProjectDataManagement::GearClass_def::AirSupport) // internal
{
// this is for party change or charge type change
if (data.partyId != m_data.partyId || data.chargeTypeId != m_data.chargeTypeId)
{
ret = m_mainHandler->chargeAdministrationHandler()->claimPlannedCharge(m_data.chargeTypeId, m_data.partyId, (-1) * m_data.impactCount);
if (ret.error())
return ret;
ret = m_mainHandler->chargeAdministrationHandler()->claimPlannedCharge(data.chargeTypeId, data.partyId, data.impactCount);
if (ret.error())
return ret;
}
else
// this is the case when cannonCount or cannonRounds changed
{
int diff = data.impactCount - m_data.impactCount;
if (diff != 0)
{
DEBUG_LOG(m_logger) << "Claiming planned charge " << diff;
ret = m_mainHandler->chargeAdministrationHandler()->claimPlannedCharge(data.chargeTypeId, data.partyId, diff);
if (ret.error())
return ret;
}
}
}
m_data = std::move(tmpData);
// m_lastSentTriggeredExplosionNumber = -1;
// reset some data:
m_aiv2.form().clear(); // enforce recalculation
m_effects.singleEffects().clear();
m_aivGunToTargetTrajectory.form().clear(); // enforce recalculation
m_temporaryData.reset(); // estimatedMaxFlightDurationMSec, mhPoints, mhWidth...
// keep in mind: if no participantId is provided: no gunToTargetLine will be calculated
if (isMhpRotationProvided())
m_temporaryData.calculatedMhpRotationNorthDeg = m_data.mhpRotationRequest;
m_data.firingCenterPosition = LtsUtils::QPoint3D(); // Core::GeoPosition();
// setupFiringOrigin
if (isOriginatorParticipantIdProvided())
{
Core::FunctionReplyObject retSFO = setupFiringOrigin();
m_temporaryData.annotationString = retSFO.translated().toStdString();
if (!isExplosionClusterMarkedValid())
m_data.effectStart = QDateTime();
}
// do checkPreConditions
{
Core::FunctionReplyObject retCPC = checkPreConditionsComplete();
if (retCPC.error())
abortPreStartTimer();
m_temporaryData.annotationString = retCPC.translated().toStdString();
if (!isExplosionClusterMarkedValid())
m_data.effectStart = QDateTime();
}
if (!m_data.effectStart.isValid())
abortPreStartTimer();
m_publishDataTimer->start();
checkEnterNewState();
DUMP();
return Core::FunctionReplyObject(data.id); // data not m_data for the possible negative id in the oc-laptop
}
bool ObjectExplosionCluster::initialCalculations(QString *reasonOut)
{
TRACE_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " START" << " id/name= '" << m_data.name << "'/" << m_data.id;
//
// calculate the subAreas / mtps:
//
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " START" << " id/name= '" << m_data.name << "'/" << m_data.id << " IS_VULCANO = " << isVulcano();
if (!isVulcano())
{
DEBUG_LOG(m_logger) << LOGFUNCTION << "GEOMETRY ID: " << m_data.explosionGeometryId << " " << "----------------------------------------";
double singleWidthOut, singleHeightOut;
singleWidthOut = singleHeightOut = 0;
// Area
const LtsCoordTrans::UtmCoordinate &impactPositionUtm = LtsCoordTrans::UtmCoordinate::fromGeographic(m_data.impactPosition); // impactPosition = cornerBottomLeft
const Polygons::AreaBottomLeft areaBLOrgWithoutTla(impactPositionUtm, m_data.impactWidth, m_data.impactLength, m_data.rotationAngle);
const Polygons::AreaBottomLeft areaBlWithTla = Polygons::explosionClusterAddTla(areaBLOrgWithoutTla, m_data.zog);
// Radial extras
const QPointF center = Polygons::bottomLeft2CenterPoint(m_data.impactPosition, m_data.impactWidth, m_data.impactLength, 0.0);
const LtsCoordTrans::UtmCoordinate &centerUtm = LtsCoordTrans::UtmCoordinate::fromGeographic(center, impactPositionUtm.zone);
const LtsCoordTrans::UtmCoordinate &firingOriginUtm = LtsCoordTrans::UtmCoordinate::fromGeographic(m_data.firingCenterPosition.toPointF());
DEBUG_LOG(m_logger) << "impactPositionUtm Coords: X: " << impactPositionUtm.x << " | Y: " << impactPositionUtm.y << " zone: " << impactPositionUtm.zone
<< "firingOriginUtm Coords: X: " << firingOriginUtm.x << " | Y: " << firingOriginUtm.y << " zone: " << firingOriginUtm.zone
<< "centerUtm Coords: X: " << centerUtm.x << " | Y: " << centerUtm.y << " zone: " << centerUtm.zone
<< " m_data.mhpCountRequest: " << m_data.mhpCountRequest;
QVector<QPointF> mtps_asUtm;
if (m_data.explosionGeometryId.underlying() == AreaEffectSimulation::AesExplosionGeometry_def::EgRadial)
mtps_asUtm = explosionClusterRadialToMtps(areaBlWithTla, m_data.mhpCountRequest, firingOriginUtm, centerUtm, &singleWidthOut, &singleHeightOut);
else
mtps_asUtm = explosionClusterAreaToMtps(areaBlWithTla, m_data.mhpCountRequest, &singleWidthOut, &singleHeightOut);
if (mtps_asUtm.size() == m_data.mhpCountRequest)
{
m_temporaryData.mhpLength = singleHeightOut;
m_temporaryData.mhpWidth = singleWidthOut;
// m_temporaryData.mhpRotation = m_data.rotationAngle; // mhpRotation depends on firingOrigin
m_temporaryData.mhPoints.clear();
// GUEZE-2746
// if less impacts are requested than mtps are provided:
if (m_data.impactCount < mtps_asUtm.size())
mtps_asUtm.resize(m_data.impactCount);
m_temporaryData.mhPoints.reserve(mtps_asUtm.size());
for (const QPointF &mtp_asUtm : qAsConst(mtps_asUtm))
{
LtsCoordTrans::UtmCoordinate temp(impactPositionUtm.zone, mtp_asUtm.x(), mtp_asUtm.y());
m_temporaryData.mhPoints.emplace_back(Core::GeoPosition2D(temp.geographic().x(), temp.geographic().y()));
} // for
} // if (mtps_asUtm.size() == m_data.mhpCountRequest)
} // if (!isVulcano())
if (!isOriginatorParticipantIdProvided())
{
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << ", no originatorParticantId -> no trajectrory";
// it's already reseted, but to make it clear:
m_temporaryData.estimatedMaxFlightDurationMSec = 0;
m_temporaryData.calculatedFiringAngle = 0;
m_temporaryData.calculatedFiringSpeed = 0;
m_temporaryData.calculatedPeakHeightAbs = 0;
m_temporaryData.calculatedFlightDurationMsec = 0;
return true;
}
//
// estimate max FlightDuration: (to start the generation of trajectories)
//
if (isVulcano())
{
// For the flightDuration more or less we have to calculate the whole curve.
// So we calculate the GTL ...
QString reasonGtlVulcanoOut;
bool successGTL = !generateGunToTargetForm(&reasonGtlVulcanoOut).empty();
if (!successGTL || !reasonGtlVulcanoOut.isEmpty())
{
ERROR_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " name= '" << m_data.name << ", generateGunToTargetForm failed"
<< ", reasonGtlVulcanoOut = " << reasonGtlVulcanoOut;
if (reasonOut)
*reasonOut = reasonGtlVulcanoOut;
return false;
}
if (!reasonGtlVulcanoOut.isEmpty())
ERROR_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " id/name= '" << m_data.name << "'/" << m_data.id << " reasonGtlVulcanoOut = " << reasonGtlVulcanoOut;
// ... and retrieve the duration:
const TracjectoryData &tdRefGTL = m_trajectoryCont[-1];
const TrajectoryTimeAware &trajTimeAwareGTL = tdRefGTL.trajectoryTimeAware;
const Core::GeoPositionRelativeTime &geoPosRelTimeRef = trajTimeAwareGTL.geometry().back();
m_temporaryData.calculatedFlightDurationMsec = geoPosRelTimeRef.relativeTime();
m_temporaryData.estimatedMaxFlightDurationMSec = (geoPosRelTimeRef.relativeTime() * 1.1) + 5 * 1000; // ( *1.1) + (10 *1000)
m_temporaryData.calculatedFiringSpeed = TrajectoryGeneratorVulcano::defaultv0();
m_temporaryData.calculatedPeakHeightAbs = tdRefGTL.peakHeightAbs;
// to avoid re-calculation, store that at m_aivGunToTargetTrajectory.
// At publishAiv the new calculation will be skipped:
m_aivGunToTargetTrajectory.form(tdRefGTL.trajectoryGeometry);
m_aivGunToTargetTrajectoryDirty = true;
}
else
{
m_temporaryData.calculatedFlightDurationMsec = Polygons::explosionClusterCalculatedFlightDuration2DMSec(m_data);
if (m_isAirSupportSource)
m_temporaryData.estimatedMaxFlightDurationMSec = m_temporaryData.calculatedFlightDurationMsec;
else
m_temporaryData.estimatedMaxFlightDurationMSec
= Polygons::explosionClusterEstimatedMaxFlightDuration2DMSec(m_temporaryData.calculatedFlightDurationMsec); // ( *1.1) + (10 *1000)
}
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << ", calculatedFlightDuration=" << m_temporaryData.calculatedFlightDurationMsec
<< ", m_estimatedMaxFlightDurationMSec=" << m_temporaryData.estimatedMaxFlightDurationMSec;
TRACE_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " END, m_estimatedMaxFlightDurationMSec=" << m_temporaryData.estimatedMaxFlightDurationMSec;
const bool ret = m_temporaryData.calculatedFlightDurationMsec > 0;
if (!ret && reasonOut)
*reasonOut = QStringLiteral("no MaxFlightDuration");
return ret;
}
void ObjectExplosionCluster::abortPreStartTimer()
{
m_preStartTimer->stop();
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << ", preStartTimer STOPPED";
}
Core::FunctionReplyObject ObjectExplosionCluster::removeObject()
{
Core::FunctionReplyObject ret = ObjectBaseTmpl::removeObject();
if (ret.error())
return ret;
// avoid unneeded calculations:
m_firingTimer.pauseFiring();
m_preStartTimer->stop();
// int chargeLeft = m_data.impactCount;
DEBUG_LOG(m_logger) << "Impact count: " << m_data.impactCount;
// DEBUG_LOG(m_logger) << "Last triggered explosion number: " << m_lastSentTriggeredExplosionNumber;
// if (isActivationTimeReached())
// chargeLeft -= m_lastSentTriggeredExplosionNumber;
int remainingAmmoCount = m_firingTimer.remainingAmmoCount();
DEBUG_LOG(m_logger) << "remainingAmmoCount: " << remainingAmmoCount;
if (remainingAmmoCount < 0)
remainingAmmoCount = 0;
DEBUG_LOG(m_logger) << "Charge left / remainingAmmoCount: " << remainingAmmoCount;
// restore original stuff
m_data.effectDuration = m_data.originalEffectDuration;
m_data.effectStart = m_data.originalEffectStart;
// Negative, as we free the charge
ret = m_mainHandler->chargeAdministrationHandler()->claimPlannedCharge(m_data.chargeTypeId, m_data.partyId, 0 - remainingAmmoCount);
return ret;
}
Core::FunctionReplyObject ObjectExplosionCluster::checkObjectData(const Database::AesExplosionCluster &data) const
{
// To avoid crashed / asserts etc
Core::FunctionReplyObject ret;
using geoType = AreaEffectSimulation::AesExplosionGeometry_def;
const geoType::type curExGeoType = data.explosionGeometryId.underlying();
static const QVector<geoType::type> ecValidGeos = {AreaEffectSimulation::AesExplosionGeometry_def::EgAimPoint, // 0 -> default
AreaEffectSimulation::AesExplosionGeometry_def::EgPoint,
AreaEffectSimulation::AesExplosionGeometry_def::EgArea,
AreaEffectSimulation::AesExplosionGeometry_def::EgRadial,
AreaEffectSimulation::AesExplosionGeometry_def::EgLine};
QString reason;
if (data.name.isEmpty())
reason = QStringLiteral("Name is empty");
else if (data.impactPosition.isNull())
reason = QStringLiteral("Position is null");
else if (data.impactLength <= 0)
reason = QString(QStringLiteral("ImpactLength invalid (%1)")).arg(data.impactLength);
else if (data.impactWidth <= 0)
reason = QString(QStringLiteral("ImpactWidth invalid (%1)")).arg(data.impactWidth);
else if (data.impactCount <= 0)
reason = QString(QStringLiteral("ImpactCount invalid (%1)")).arg(data.impactCount);
else if (!ecValidGeos.contains(curExGeoType))
reason = QString(QStringLiteral("ExplosionGeometryType not supported yet (%1)")).arg(static_cast<int>(curExGeoType));
// else if ((curExGeoType == AreaEffectSimulation::AesExplosionGeometry_def::EgArea) &&
// (data.impactCount <= 2))
// reason = QString(QStringLiteral("ImpactCount invalid (%1)")).arg(QStringLiteral("Area requires at least 2 impacts"));
else if (data.zog < 0)
reason = QString(QStringLiteral("TLA invalid (%1)")).arg(data.zog);
else if (data.mhpCountRequest < 0)
reason = QString(QStringLiteral("mhpCountRequest invalid (%1)")).arg(data.mhpCountRequest);
// LaserGuiding:
else if (data.launchVelocity < -1)
reason = QString(QStringLiteral("launchVelocity invalid (%1)")).arg(data.launchVelocity);
else if ((data.launchAngleDeg < -1) || (data.launchAngleDeg > 90))
reason = QString(QStringLiteral("launchAngleDeg invalid (%1)")).arg(data.launchAngleDeg);
else if ((data.dropAngle < -1) || (data.dropAngle > 90))
reason = QString(QStringLiteral("dropAngle invalid (%1)")).arg(data.dropAngle);
// finally
if (!reason.isEmpty())
{
ret = Core::FunctionReplyObject(m_data.id, tr_lts("dds", "Explosion cluster with id %1 and name '%2' invalid. (%3)")).arg(m_data.id).arg(m_data.name).arg(reason);
ERROR_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " Error: " << ret.translated();
}
return ret;
}
bool ObjectExplosionCluster::removeObjectFromDb() { return m_mainHandler->db()->removeAesExplosionCluster(m_data.id); }
Core::FunctionReplyObject ObjectExplosionCluster::resumePause(const ExplosionClusterPauseResumeRequest &req)
{
Core::FunctionReplyObject ret;
if (req.resumeExecution())
{
// resume
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " RESUME" << " ... ";
if (m_firingTimer.remainingAmmoCount() <= 0)
ret = Core::FunctionReplyObject(m_data.id, tr_lts("dds", "Explosion cluster with id %1 and name '%2' could not be resumed (%3)"))
.arg(m_data.id)
.arg(m_data.name)
.arg(tr("no ammo left"));
else if (!m_firingTimer.startFiring())
ret = Core::FunctionReplyObject(m_data.id, tr_lts("dds", "Explosion cluster with id %1 and name '%2' could not be resumed (%3)")).arg(m_data.id).arg(m_data.name);
}
else
{
// pause
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " PAUSE" << " ... ";
if (m_firingTimer.remainingAmmoCount() <= 0)
ret = Core::FunctionReplyObject(m_data.id, tr_lts("dds", "Explosion cluster with id %1 and name '%2' could not be paused (%3)"))
.arg(m_data.id)
.arg(m_data.name)
.arg(tr("no ammo left"));
else if (!m_firingTimer.pauseFiring())
ret = Core::FunctionReplyObject(m_data.id, tr_lts("dds", "Explosion cluster with id %1 and name '%2' could not be paused")).arg(m_data.id).arg(m_data.name);
}
if (ret.error())
ERROR_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " PAUSE" << " ... resumePause failed"
<< ", errorStr = " << ret.translated();
return ret;
//
// if (req.resumeExecution())
// {
// // resume
// if (req.timeToResume().is_set())
// m_data.effectStart = QDateTime::fromMSecsSinceEpoch(req.timeToResume().get());
// else
// m_data.effectStart = partitionTime();
// if (req.remainingDuration().is_set())
// m_data.effectDuration = req.remainingDuration().get();
// // req.resumeSeed() currently not used, as it is calculated internaly. maybe in the future
// if (!trySwitchToActivated())
// return Core::FunctionReplyObject(m_data.id, tr_lts("dds", "Explosion cluster is currently not paused."));
// }
// else
// // pause
// if (!trySwitchToPaused())
// return Core::FunctionReplyObject(m_data.id, tr_lts("dds", "Switching explosion cluster to pause is not possible in the current state."));
// //m_lastSentTriggeredExplosionNumber = -1;
// return Core::FunctionReplyObject(m_data.id);
//
}
Core::FunctionReplyObject ObjectExplosionCluster::targetPositionsModify(const TargetPositionsModifyRequest &req)
{
static int s_counter = 0;
const qint64 now = partitionTimeMSec();
const qint64 remainingMsec = m_data.effectStart.toMSecsSinceEpoch() - now;
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " START"
<< " TargetPositionsModifyRequest = " << req << ", s_counter = " << s_counter++ << ", current state = " << m_data.effectStateId.underlying()
<< ", now = " << now << ", effectStart = " << m_data.effectStart.toMSecsSinceEpoch() << ", remainingMsec = " << remainingMsec;
DUMP();
const std::vector<Core::GeoPosition> &positions = req.positions();
Core::FunctionReplyObject ret;
if (m_data.effectStateId.underlying() == AreaEffectSimulation::AesEffectState_def::EsExpired)
{
ret = Core::FunctionReplyObject(m_data.id, tr_lts("dds", "Error modifying explosion cluster with id %1 since object is already expired")).arg(m_data.id);
ERROR_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " Error: " << ret.str();
return ret;
}
// check size
if (positions.empty() || (m_data.mhpCountRequest != static_cast<int>(positions.size())))
{
ret = Core::FunctionReplyObject(m_data.id, tr_lts("dds", "Error modifying explosion cluster with id %1 since size does not match")).arg(m_data.id);
ERROR_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " Error: " << ret.str();
return ret;
}
// check isVulcano:
if (!isVulcano())
{
ret = Core::FunctionReplyObject(m_data.id, tr_lts("dds", "Error modifying explosion cluster with id %1 is not supported for this charge type")).arg(m_data.id);
ERROR_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " Error: " << ret.str();
return ret;
}
// check Time:
// accept targetPositionsModify only if effectStart is NOT reached:
if (remainingMsec < 0)
{
ret = Core::FunctionReplyObject(m_data.id, tr_lts("dds", "Error modifying explosion cluster with id %1 since object is already active (it's %2 msec to late) "))
.arg(m_data.id)
.arg(remainingMsec);
ERROR_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " Error: " << ret.translated();
return ret;
}
const Core::GeoPosition &newTargetPos = req.positions().front();
const int explosionIndex = 0;
TracjectoryData &tdRef = m_trajectoryCont[explosionIndex];
TrajectoryTimeAware &trajTimeAwareRef = tdRef.trajectoryTimeAware;
std::vector<Core::GeoPositionRelativeTime> &trajectoryTimeAwareGeometry = trajTimeAwareRef.geometry();
if (trajectoryTimeAwareGeometry.empty())
{
ERROR_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " has no trajectoryTimeAwareGeometry";
ret = Core::FunctionReplyObject(m_data.id, tr_lts("dds", "Error modifying explosion cluster with id %1 since trajectory is empty")).arg(m_data.id);
return ret;
}
// "adjust" by replacing the last GeoPosition by the new value, but leave the timepoint untouched:
Core::GeoPosition &hitPos = trajectoryTimeAwareGeometry.back(); // implicit downcast
hitPos = newTargetPos;
// // look for youngest item:
// const qint64 now = partitionTimeMSec();
// const qint64 starttime = trajTimeAwareRef.effectStart();
// const Core::GeoPositionRelativeTime lastItemCopy = trajectoryTimeAwareGeometry.back();
// for (unsigned int adjustIndex = trajectoryTimeAwareGeometry.size() - 1; adjustIndex > 0; --adjustIndex)
// {
// const Core::GeoPositionRelativeTime &curItem_geo = trajectoryTimeAwareGeometry[adjustIndex-1];
// if ((starttime + curItem_geo.relativeTime()) > now)
// {
// // remove...
// trajectoryTimeAwareGeometry.pop_back();
// continue;
// }
// // ... and set new end/back:
// trajectoryTimeAwareGeometry.emplace_back(Core::GeoPositionRelativeTime(newTargetPos.lon(),
// newTargetPos.lat(),
// newTargetPos.z(),
// lastItemCopy.relativeTime()) );
// } // for
// DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " XXXX"
// << " trajectoryTimeAwareGeometry size = " << trajectoryTimeAwareGeometry.size();
// m_aiv2 CHANGES HERE
//
std::vector<Core::GeoPosition> &formRef = m_aiv2.form();
// compare former and updated ImpactPos: context targetModify
if (m_logger.isDebugEnabled())
{
Core::GeoPosition &curImpactPosRef = formRef[explosionIndex];
LtsCoordTrans::UtmCoordinate utm1 = LtsCoordTrans::UtmCoordinate::fromGeographic(curImpactPosRef.lon(), curImpactPosRef.lat());
const QVector3D u1Vec(utm1.x, utm1.y, curImpactPosRef.z());
LtsCoordTrans::UtmCoordinate utm2 = LtsCoordTrans::UtmCoordinate::fromGeographic(newTargetPos.lon(), newTargetPos.lat(), utm1.zone);
const QVector3D u2Vec(utm2.x, utm2.y, newTargetPos.z());
const QVector3D diff = u2Vec - u1Vec;
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " for explosionIndex " << explosionIndex << ", curImpactPosRef " << curImpactPosRef << ", utm1 " << utm1
<< ", newTargetPos " << newTargetPos << ", utm2 " << utm2 << " the impactPos moved 2D = " << LtsCoordTrans::distance(utm1, utm2)
<< " the impactPos moved 3D = " << diff.length();
}
Core::GeoPosition &curImpactPosRef = formRef[explosionIndex];
curImpactPosRef = newTargetPos;
// Effects:
std::vector<AreaEffectSimulation::SingleEffect> &singleEffectsRef = m_effects.singleEffects();
SingleEffect &ref = singleEffectsRef[explosionIndex];
ref.position(newTargetPos);
ref.zPlacement(AesZPlacement_def::ZpAbsolute); // intersection: change from draped to absolute
// Trajectory
publishTrajectory(explosionIndex);
if (ret.error())
ERROR_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " some checks failed";
return ret;
}
Core::FunctionReplyObject ObjectExplosionCluster::checkPreConditionsComplete()
{
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " START";
DUMP();
QString reason;
if (m_data.externalId <= 0) // -> internal
{
if (m_data.participantId == 0)
{
WARNING_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << ", m_data.participantId invalid: " << m_data.participantId;
reason = QString(QStringLiteral("firingParticipantId is invalid (%1)")).arg(m_data.participantId);
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " END";
DUMP();
return createAnnotationObjectIncomplete(m_data.id, reason);
}
if ((m_data.participantId > 0) && !firingOriginIsValid(m_data.firingCenterPosition, &reason))
{
ERROR_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " firingOriginIsValid failed";
if (!reason.isEmpty())
{
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " END";
DUMP();
return createAnnotationObjectIncomplete(m_data.id, reason);
}
}
if (!initialCalculations(&reason) || !reason.isEmpty())
{
ERROR_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " initialCalculations failed";
DUMP();
return createAnnotationObjectError(m_data.id, reason);
}
} // if (m_data.externalId <= 0)
// keep start of svc in mind:
Core::FunctionReplyObject ret;
if (m_data.effectStateId.underlying() != AreaEffectSimulation::AesEffectState_def::EsExpired)
ret = checkPreConditions();
DUMP();
if (ret.error())
ERROR_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " checkPreConditions failed";
return ret;
}
Core::FunctionReplyObject ObjectExplosionCluster::checkPreConditions()
{
// setupParticipantOrigin, initialCalculations should be executed.
QString reason;
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " START";
//
// check time
//
m_preStartTimer->stop();
if (!activationTime().isNull() && isOriginatorParticipantIdProvided()) // no originatorParticipantId provided, so no trajectory is intended
{
m_preStartTimer->stop();
const qint64 timeUntilFireMSec = activationTime().toMSecsSinceEpoch() - m_temporaryData.estimatedMaxFlightDurationMSec - partitionTimeMSec();
// to support 'late' / 'immediate' requests and avoid 'Error, not enough time for estimated flight duration'
// following may work:
// if (timeUntilFireMSec < 0)
// timeUntilFireMSec = 0;
if (timeUntilFireMSec < 0)
{
ERROR_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " Error, not enough time for estimated flight duration"
<< " estimatedMaxFlightDurationMSec=" << m_temporaryData.estimatedMaxFlightDurationMSec << " (timeUntilFireMSec=" << timeUntilFireMSec
<< " < 0 ";
reason = QString(QStringLiteral("Not enough time for estimated flight duration (timeUntilFireMSec=%1).")).arg(timeUntilFireMSec);
}
else
{
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " preStartTimer->setInterval, timeUntilFireMSec = " << timeUntilFireMSec;
m_preStartTimer->setInterval(timeUntilFireMSec);
// m_preStartTimer->setInterval(5000);
m_preStartTimer->start();
}
// slot: checkNextFire
}
if (!reason.isEmpty())
{
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " END";
return createAnnotationObject(m_data.id, reason);
}
//
// check GunToTargetForm (generates trajectory to center of area.)
// It will use flightDuration or peakHeight as provided
//
if (isOriginatorParticipantIdProvided())
{
QString reasonGtlOut;
m_temporaryData.gunToTargetLine = ObjectExplosionCluster::generateGunToTargetForm(&reasonGtlOut);
if (m_temporaryData.gunToTargetLine.size() < 2)
reason = QString(QStringLiteral("GenerateGunToTargetLine (%1)")).arg(reasonGtlOut);
if (!reason.isEmpty())
{
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " END";
return createAnnotationObjectError(m_data.id, reason);
}
}
return Core::FunctionReplyObject(m_data.id);
}
void ObjectExplosionCluster::setEffectState(AesEffectState newState)
{
// if (newState == AesEffectState::EsPaused ||
// newState == AesEffectState::EsExpired ||
// newState == AesEffectState::EsRemoved ||
// newState == AesEffectState::EsUnknown)
// stopSingleExplosionHandling(newState);
// more or less a hack for ec of HLA (m_explosionCluster.externalId() > 0)
bool bExecuteFiringImpact = false;
if (noTracjectoryRequired() && (m_data.effectStateId != AesEffectState::EsActivated) && (newState == AesEffectState::EsActivated))
bExecuteFiringImpact = true;
ObjectBaseTmpl::setEffectState(newState);
// if (newState == AesEffectState::EsActivated)
// startSingleExplosionHandling();
if (newState == AesEffectState::EsCreated || newState == AesEffectState::EsError || newState == AesEffectState::EsReceived)
{
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << ", setEffectState to " << newState;
abortPreStartTimer();
}
if (bExecuteFiringImpact)
{
m_temporaryData.calculatedFlightDurationMsec = 0;
checkNextFire();
}
m_publishDataTimer->start();
}
void ObjectExplosionCluster::onPublishData()
{
ObjectBaseTmpl::onPublishData();
if (!m_mainHandler->db()->update(m_data))
ERROR_LOG(m_logger) << "Error updating ObjectExplosionCluster-data in database";
ExplosionCluster ddsData(m_data.id,
m_data.name.toStdString(),
effectState() == AesEffectState::EsRemoved,
false,
0, // partitionTimeMSec(),
{m_data.chargeTypeId, m_data.igniterTypeId, m_data.igniterFunctionId},
m_data.effectDuration, // pause/resume: remainDuration
toOptional(toMSec(m_data.effectStart)),
m_data.effectStateId,
m_data.effectSourceId,
toOptional(m_data.partyId),
toOptional(m_data.participantId),
m_data.effectMarkingInTa,
m_data.externalId,
m_data.isCentral,
m_data.properties.toStdString(),
m_data.element.toStdString(),
m_temporaryData.annotationString, // relevant for "isExplosionClusterValid()
Area(Core::GeoPosition2D(m_data.impactPosition.x(), m_data.impactPosition.y()), m_data.impactWidth, m_data.impactLength, m_data.rotationAngle),
m_data.explosionGeometryId,
m_data.zog, // aka zog
m_temporaryData.mhPoints,
m_temporaryData.mhpWidth,
m_temporaryData.mhpLength,
m_temporaryData.calculatedMhpRotationNorthDeg,
m_data.impactCount,
// -1, // currentExplosionNumber(), currentExplosionNumber is skipped until stop/resume is implemented
// m_firingTimer.nextAmmoToFire(),
m_data.remainExplosionNumber, // is more _NEXT_ ExplosionNumber
toMSec(m_data.fireRequestTime),
m_data.firePurposeId, // m_data.firePurpose.toStdString(),
toCoreGeoPosition(m_data.firingCenterPosition),
toMSec(m_data.originalEffectStart),
m_data.originalEffectDuration,
m_temporaryData.isObjectModifiable,
dds::core::optional<AreaEffectSimulation::FlightCurve>(),
dds::core::optional<AreaEffectSimulation::LaserGuiding>(),
m_data.esmParticipantIds());
// add FlightCurve only if SingleEffectOnly == (externalId > 0)
if (m_data.externalId == 0)
{
FlightCurve fc(m_data.launchVelocity,
m_data.launchAngleDeg,
m_data.dropAngle,
m_temporaryData.calculatedFiringSpeed,
m_temporaryData.calculatedPeakHeightAbs,
m_temporaryData.calculatedFlightDurationMsec,
m_data.peakHeight,
m_data.flightDuration);
ddsData.flightCurve(toOptional(fc));
}
if (isVulcano())
{
LaserGuiding lg(m_data.lcPrf, m_data.lcTermination, m_data.tapTimepoint, m_data.cloudBase);
ddsData.laserGuiding(toOptional(lg));
}
// publish only on real changes:
if (m_explosionCluster != ddsData)
{
m_explosionCluster = ddsData;
ddsData.sampleTime(partitionTimeMSec()); // publish sampleTime, but do not store
m_mainHandler->dds()->dts()->publish(ddsData);
}
publishAiv();
}
void ObjectExplosionCluster::onDetonationLocationReply(const DetonationLocationReply &reply)
{
TRACE_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " START";
// int32_t aesItemId, // aesItemId
// const std::string& annotationString,
// const std::vector< std::string >& errorParams,
// int32_t explosionIndex, // explosionIndex
// const Core::GeoPosition& position);
if (reply.id() != m_data.id) // aesItemId
{
DEBUG_LOG(m_logger) << "ID mismatch: " << reply.id() << " != " << m_data.id;
return;
}
// do we have the initial geometry?
const int explosionIndex = reply.index();
if (!m_trajectoryCont.contains(explosionIndex))
{
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << "unknown explosionIndex "
<< ", reply.index() = " << explosionIndex;
return;
}
const Core::GeoPosition &replyPos = reply.position();
if ((replyPos.lon() < 0.00001) || (replyPos.lat() < 0.00001))
{
// no intersection
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " got DetonationLocationReply"
<< " : no intersection - reply.position is: "
<< ", reply.index() = " << explosionIndex << ", reply.position() " << replyPos;
}
else
{
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " got DetonationLocationReply"
<< " : INTERSECTION - reply.position is: "
<< ", reply.index() = " << explosionIndex << ", reply.position() " << replyPos;
adjustTrajectoryToDetonationLocation(explosionIndex, replyPos, reply.buildingId());
}
// publish new triggered explosions data here
// first new positions...
if (m_aiv2HasChanged)
{
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " Publishing AesItemView (AtExplosionClusterSingleExplosions) for TriggeredExplosions, explosionIndex "
<< explosionIndex;
m_aiv2.sampleTime(partitionTimeMSec());
// // m_mainHandler->dds()->dts()->publish(m_aiv2); // does anyone needs this topic???
m_aiv2HasChanged = false;
emit newAiv(m_aiv2);
}
else
{
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id
<< " Publishing AesItemView (AtExplosionClusterSingleExplosions) for TriggeredExplosions SKIPPED, explosionIndex " << explosionIndex;
}
publishTrajectory(explosionIndex);
TRACE_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " END";
}
void ObjectExplosionCluster::adjustTrajectoryToDetonationLocation(int explosionIndex, const Core::GeoPosition &intersectionLocation, const int buildingId)
{
TRACE_LOG(m_logger) << "adjustTrajectoryToDetonationLocation " << m_data.id << " START";
// do we have the initial geometry?
if (!m_trajectoryCont.contains(explosionIndex))
{
ERROR_LOG(m_logger) << "adjustTrajectoryToDetonationLocation " << m_data.id << "unknown explosionIndex "
<< ", reply.index() = " << explosionIndex;
return;
}
TracjectoryData &tdRef = m_trajectoryCont[explosionIndex];
tdRef.buildingId = buildingId;
std::vector<Core::GeoPosition> &trajectoryGeometry = tdRef.trajectoryGeometry;
if (trajectoryGeometry.empty())
{
ERROR_LOG(m_logger) << "adjustTrajectoryToDetonationLocation " << m_data.id << " trajectory is empty";
return;
}
DEBUG_LOG(m_logger) << "adjustTrajectoryToDetonationLocation " << m_data.id << "VOR : m_trajectory.size()=" << trajectoryGeometry.size()
<< " back: " << trajectoryGeometry.back();
const Core::GeoPosition &trajBack = trajectoryGeometry.back();
if (trajectoryGeometry.back() == intersectionLocation) // no adjustment necessary
{
DEBUG_LOG(m_logger) << "Detonation/Intersection location coincides with last point of trajectory for ID: " << m_data.id;
return;
}
const Core::GeoPosition &trajFront = trajectoryGeometry.front();
const double distToOriginSquared = LtsCoordTrans::squareDistance(trajFront.lon(), trajFront.lat(), intersectionLocation.lon(), intersectionLocation.lat());
ProjectDataManagement::IgniterFunctionBase ignFunctionBase
= m_mainHandler->dds()
->pdmDtc()
->getChargeTypeIgniterTypeIgniterFunction(m_data.chargeTypeId, m_data.igniterTypeId, m_data.igniterFunctionId)
.igniterFunctionBaseId();
if ((ignFunctionBase == ProjectDataManagement::IgniterFunctionBase::IfbProximity) || (ignFunctionBase == ProjectDataManagement::IgniterFunctionBase::IfbImpact))
{
const double distTrajectorySquared = LtsCoordTrans::squareDistance(trajFront.lon(), trajFront.lat(), trajBack.lon(), trajBack.lat());
if (distToOriginSquared > distTrajectorySquared)
{
ERROR_LOG(m_logger) << "adjustTrajectoryToDetonationLocation " << m_data.id << "Detonation location is outside of trajectory for ID: " << m_data.id
<< ", explosionIndex=" << explosionIndex;
return;
} // if
}
bool bAdjusted = false;
// reverse iteration;
const Core::GeoPosition &trajectoryOrigin_geo = trajFront;
for (unsigned int i = trajectoryGeometry.size() - 1; i > 0; --i)
{
const Core::GeoPosition &curItem_geo = trajectoryGeometry[i - 1];
const double distStartSegmentSquared = LtsCoordTrans::squareDistance(curItem_geo.lon(), curItem_geo.lat(), trajectoryOrigin_geo.lon(), trajectoryOrigin_geo.lat());
// remove...
if (distStartSegmentSquared > distToOriginSquared)
{
trajectoryGeometry.pop_back();
continue;
} // if
// ... and set new end/back:
trajectoryGeometry.pop_back();
trajectoryGeometry.push_back(intersectionLocation);
bAdjusted = true;
} // for
if (bAdjusted)
{
// 'adjust' the according SingleExlosions position!?
// initially form has no zValue, but we replace the ideal impact with the intersectionLocation (with zValue)
//
// m_aiv2 CHANGES HERE
//
std::vector<Core::GeoPosition> &formRef = m_aiv2.form();
Core::GeoPosition &curImpactPosRef = formRef[explosionIndex];
// compare former and updated ImpactPos: context intersection
if (m_logger.isDebugEnabled())
{
LtsCoordTrans::UtmCoordinate utm1 = LtsCoordTrans::UtmCoordinate::fromGeographic(curImpactPosRef.lon(), curImpactPosRef.lat());
const QVector3D u1Vec(utm1.x, utm1.y, curImpactPosRef.z());
LtsCoordTrans::UtmCoordinate utm2 = LtsCoordTrans::UtmCoordinate::fromGeographic(intersectionLocation.lon(), intersectionLocation.lat(), utm1.zone);
const QVector3D u2Vec(utm2.x, utm2.y, intersectionLocation.z());
const QVector3D diff = u2Vec - u1Vec;
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " for explosionIndex " << explosionIndex << ", curImpactPosRef " << curImpactPosRef << ", utm1 " << utm1
<< ", intersectionLocation " << intersectionLocation << ", utm2 " << utm2 << " the impactPos moved 2D = " << LtsCoordTrans::distance(utm1, utm2)
<< " the impactPos moved 3D = " << diff.length();
}
curImpactPosRef = intersectionLocation;
m_aiv2HasChanged = true;
// Effects:
std::vector<AreaEffectSimulation::SingleEffect> &singleEffectsRef = m_effects.singleEffects();
SingleEffect &ref = singleEffectsRef[explosionIndex];
// ref.effectState(AesSingleEffectState_def::SesScheduled);
ref.position(intersectionLocation);
ref.zPlacement(AesZPlacement_def::ZpAbsolute); // intersection: change from draped to relative
// m_effectsHaveChanged = true;
if (explosionIndex == m_data.impactCount - 1)
DEBUG_LOG(m_logger) << "adjustTrajectoryToDetonationLocation " << m_data.id << ", update SingleExlosion: "
<< ", explosionIndex=" << explosionIndex << ", intersectionLocation=" << intersectionLocation;
else
DEBUG_LOG(m_logger) << "adjustTrajectoryToDetonationLocation " << m_data.id << ", update SingleExlosion: "
<< ", explosionIndex=" << explosionIndex << ", intersectionLocation=" << intersectionLocation;
}
DEBUG_LOG(m_logger) << "adjustTrajectoryToDetonationLocation " << m_data.id << ", Trajectory bAdjusted: " << bAdjusted
<< ", m_trajectory.size()=" << trajectoryGeometry.size() << " back: " << trajectoryGeometry.back();
TRACE_LOG(m_logger) << "adjustTrajectoryToDetonationLocation, " << m_data.id << " END";
}
// void ObjectExplosionCluster::setTrajectoryStartTime(int explosionIndex)
//{
// TRACE_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " START, explosionIndex = " << explosionIndex;
// // Pause/Resume has to be considered.
// // use simple approach until then:
// // startime = impactTime - flightDuration
// const qint64 effectDurationMSec = m_data.effectDuration;
// // smooth:
// // Erst Schuss direct am Anfang, letzter Schuss am Ende
// // Bsp: dur = 10sec ; impactCount = 2;
// // intervalMSec = 10 / 1 = 10;
// // ^ !
// // Also bei effectStart und bei effectStart+effectDuration
// //
// qint64 intervalMSec;
// if (m_data.impactCount > 1)
// intervalMSec = effectDurationMSec / (m_data.impactCount);
// else
// intervalMSec = effectDurationMSec;
// const qint64 effectStartMSec = m_data.effectStart.toMSecsSinceEpoch();
// const qint64 impactTimeMSec = effectStartMSec + (explosionIndex*intervalMSec);
// DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " explosionIndex = " << explosionIndex
// << ", impactTimeMSec= " << QDateTime::fromMSecsSinceEpoch(impactTimeMSec).toString();
// // save to m_trajectoryCont:
// TracjectoryData &tdRef = m_trajectoryCont[explosionIndex];
// tdRef.trajectoryTimeAware.trajectoryStartTime(impactTimeMSec - tdRef.flightDurationMSec);
// DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " explosionIndex = " << explosionIndex
// << ", trajectoryStartTime = " << QDateTime::fromMSecsSinceEpoch(tdRef.trajectoryTimeAware.trajectoryStartTime()).toString()
// << ", trajectoryStartTime [msec] = " << tdRef.trajectoryTimeAware.trajectoryStartTime()
// << ", tdRef.flightDurationMSec [msec] = " << tdRef.flightDurationMSec
// << ", impactTimeMSec= " << QDateTime::fromMSecsSinceEpoch(impactTimeMSec).toString();
// TRACE_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " END, explosionIndex = " << explosionIndex;
//}
Core::FunctionReplyObject ObjectExplosionCluster::setupFiringOrigin()
{
TRACE_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " START";
QString reason;
LtsUtils::QPoint3D geoPosOut;
if (!getFiringUnitOrigin(m_data.participantId, geoPosOut, &reason))
{
ERROR_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " getFiringOrigin failed for id " << m_data.participantId << ", reason: '" << reason << "'";
if (!reason.isEmpty())
{
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " END";
DUMP();
return createAnnotationObjectIncomplete(m_data.id, reason);
}
}
m_data.firingCenterPosition = geoPosOut;
TRACE_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " END";
return Core::FunctionReplyObject();
}
void ObjectExplosionCluster::publishAiv()
{
const bool isEcValid = isExplosionClusterMarkedValid();
QPolygonF poly;
// [GUEZE-2487] PointGeometry:
// Move circle / form to real impact:
const bool bIsPoint = isPointSimilar(m_data.explosionGeometryId);
if (bIsPoint && (m_lastSentTriggeredExplosionNumber == 1)) // 'move' only AFTER impact
{
// on svcRestart, m_aiv2 may not been set. To avoid crash:
const std::vector<Core::GeoPosition> &formRef = m_aiv2.form();
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " since isPointSimilar==true form has to be updated"
<< ", m_data.effectStateId = " << m_data.effectStateId << ", m_data.impactWidth = " << m_data.impactWidth
<< ", m_lastSentTriggeredExplosionNumber = " << m_lastSentTriggeredExplosionNumber << ", formRef.size() = " << formRef.size();
QPointF centerGeo;
// on svcRestart, m_aiv2 may not been set. To avoid crash:
if (formRef.empty())
{
centerGeo = AreaEffectSimulation::Polygons::bottomLeft2CenterPoint(m_data.impactPosition, m_data.impactWidth, m_data.impactLength, m_data.rotationAngle);
}
else
{
const Core::GeoPosition &impactPosition_geo3D = formRef[0];
centerGeo = QPointF(impactPosition_geo3D.lon(), impactPosition_geo3D.lat());
}
// ... and now take zog into account:
double radius = m_data.impactWidth / 2.0;
if (radius < 1)
radius = 1;
poly = Polygons::circle(centerGeo, radius + m_data.zog);
}
else
{
poly = Polygons::explosionClusterArea(m_data);
}
const QRectF bounds(poly.boundingRect());
//
// Major
//
AesItemView aiv(m_aiv);
aiv.aesItemId(m_data.id);
aiv.chargeStruct().chargeTypeId(m_data.chargeTypeId);
aiv.effectStart(toMSec(m_data.effectStart));
ddsVecFromPoly(poly, aiv.form());
aiv.boundingBoxBottomLeft(Core::GeoPosition2D(bounds.topLeft().x(), bounds.topLeft().y())); // QRectF's bigger values are at bottom
aiv.boundingBoxTopRight(Core::GeoPosition2D(bounds.bottomRight().x(), bounds.bottomRight().y()));
aiv.aesTypeId(AesType::AtExplosionCluster);
aiv.effectStateId(effectState());
aiv.id(1000 * m_data.id + AesType::AtExplosionCluster);
if (m_data.partyId != 0)
aiv.partyId(m_data.partyId);
// ObjectBaseTmpl::checkIsCentral honors pdm->isLaserGuidable
// and therefore isCentral is set to true; )
checkIsCentralAndPublish(aiv.form(), m_aiv.form(), m_data.isCentral);
//
// SingleExplosions
//
if (isEcValid)
{
AesItemView aiv2(m_aiv2);
aiv2.aesItemId(m_data.id);
aiv2.chargeStruct().chargeTypeId(m_data.chargeTypeId);
aiv2.effectStart(toMSec(m_data.effectStart));
// calculate just one time.
// maybe intersections of trajectories with building will 'adjust' some impact positions later.
if (aiv2.form().empty())
{
if (isVulcano() || (m_data.externalId > 0)) // m_data.externalId > 0 -> HLA / SingleFire / PointGeometry
{
const QPointF &impactPointGeo
= AreaEffectSimulation::Polygons::bottomLeft2CenterPoint(m_data.impactPosition, m_data.impactWidth, m_data.impactLength, m_data.rotationAngle);
ddsVecFromPoly(QVector<QPointF>() << impactPointGeo, aiv2.form());
}
else
{
const QVector<QPointF> &singleExplosions = Polygons::explosionClusterSingleExplosionsGAUSS_Mtp(m_data, m_temporaryData.calculatedMhpRotationNorthDeg);
ddsVecFromPoly(singleExplosions, aiv2.form());
}
}
aiv2.boundingBoxBottomLeft(aiv.boundingBoxBottomLeft());
aiv2.boundingBoxTopRight(aiv.boundingBoxTopRight());
aiv2.aesTypeId(AesType::AtExplosionClusterSingleExplosions);
aiv2.id(1000 * m_data.id + AesType::AtExplosionClusterSingleExplosions);
aiv2.effectStateId(effectState());
if (m_data.partyId != 0)
aiv2.partyId(m_data.partyId);
//
// m_aiv2 CHANGES HERE
//
m_aiv2 = aiv2;
// if (aiv2 != m_aiv2)
// {
// m_aiv2 = aiv2;
// aiv2.sampleTime(partitionTimeMSec()); // publish sampleTime, but do not store
// m_mainHandler->dds()->dts()->publish(aiv2);
// emit newAiv(aiv2);
// }
m_effects.id(1000 * m_data.id + AesType::AtExplosionClusterSingleExplosions);
m_effects.aesItemId(m_data.id);
m_effects.aesTypeId(AesType::AtExplosionClusterSingleExplosions);
std::vector<AreaEffectSimulation::SingleEffect> &singleEffectsRef = m_effects.singleEffects();
if (singleEffectsRef.empty())
{
if (isVulcano() || (m_data.externalId > 0)) // m_data.externalId > 0 -> HLA / SingleFire / PointGeometry
{
singleEffectsRef.resize(1);
SingleEffect &seRef = singleEffectsRef.front();
seRef.singleEffectState(AesSingleEffectState_def::SesScheduled);
const QPointF &impactPointGeo
= AreaEffectSimulation::Polygons::bottomLeft2CenterPoint(m_data.impactPosition, m_data.impactWidth, m_data.impactLength, m_data.rotationAngle);
// seRef.position(Core::GeoPosition(impactPointGeo.x(), impactPointGeo.y(), 0.0));
const double elevation = getElevationFor(impactPointGeo, QStringLiteral("getElevationForSingleImpactVulcano"));
seRef.position(Core::GeoPosition(impactPointGeo.x(), impactPointGeo.y(), elevation));
seRef.zPlacement(AesZPlacement_def::ZpDraped);
}
else
{
const QVector<QPointF> &singleExplosions = Polygons::explosionClusterSingleExplosionsGAUSS_Mtp(m_data, m_temporaryData.calculatedMhpRotationNorthDeg);
int explosionIndex = 0;
singleEffectsRef.reserve(singleExplosions.size());
for (const QPointF &singleExplosion : qAsConst(singleExplosions))
{
SingleEffect se;
se.singleEffectState(AesSingleEffectState_def::SesScheduled);
// se.position(Core::GeoPosition(singleExplosion.x(), singleExplosion.y(), 0.0));
const double elevation = getElevationFor(singleExplosion, QStringLiteral("getElevationForSingleEffect"));
se.position(Core::GeoPosition(singleExplosion.x(), singleExplosion.y(), elevation));
se.zPlacement(AesZPlacement_def::ZpDraped);
// // se.effectTime();
singleEffectsRef.push_back(se);
++explosionIndex;
} // for
} // if (isVulcano())
}
}
else
{
auto dts = m_mainHandler->dds()->dts();
dts->removeAesItemViewByKey(1000 * m_data.id + AesType::AtExplosionClusterSingleExplosions);
// up to s_maxTrajectoriesPerExplosionCluster are supported. One sample per trajectory.
const bool errorMsgIfSampleDoesNotExists = false;
dts->removeEffectsByKey(1000 * m_data.id + AesType::AtExplosionClusterSingleExplosions, errorMsgIfSampleDoesNotExists);
}
//
// GunToTargetTrajectory
//
// EsUnknown = 0,
// EsError = 255,
// EsExpired = 1,
// EsRemoved = 2,
// EsCreated = 4,
// EsPrepared = 5,
// EsActivated = 6,
// EsPaused = 7
// AtExplosionClusterGunToTargetLine is suppressed at map display, when main object changes to EsActivated
// So it does not have to be changed/published anymore.
// Especially helpful while restarting scvAes!
static QVector<AesEffectState_def::type> relevantEffStates = {
AesEffectState_def::EsCreated,
AesEffectState_def::EsPrepared,
AesEffectState_def::EsActivated, // 2026-05-27, N.Thoden: E01562-393: GTL auch bei EsFired anzeigen, daher auch bei EsActivated
AesEffectState_def::EsFired, // 2026-05-27, N.Thoden: E01562-393: GTL auch bei EsFired anzeigen
};
DEBUG_LOG(m_logger) << " AtExplosionClusterGunToTargetLine RELEVANT " << relevantEffStates.contains(effectState().underlying()) << ", id " << m_data.id;
if (isEcValid && isOriginatorParticipantIdProvided() && // no Originator -> no curve
relevantEffStates.contains(effectState().underlying()))
{
AesItemView aiv3(m_aivGunToTargetTrajectory);
aiv3.aesItemId(m_data.id);
aiv3.chargeStruct().chargeTypeId(m_data.chargeTypeId);
// aiv3.effectStart(0);
if (aiv3.form().empty())
{
const std::vector<Core::GeoPosition> &form = ObjectExplosionCluster::generateGunToTargetForm();
aiv3.form(form);
if (form.size() > 2)
{
QPolygonF polyGTL;
polyGTL.reserve(2);
polyGTL.push_back(QPointF(form.front().lon(), form.front().lat()));
polyGTL.push_back(QPointF(form.back().lon(), form.back().lat()));
const QRectF boundsGTL(polyGTL.boundingRect());
aiv3.boundingBoxBottomLeft(Core::GeoPosition2D(boundsGTL.topLeft().x(), boundsGTL.topLeft().y())); // QRectF's bigger values are at bottom
aiv3.boundingBoxTopRight(Core::GeoPosition2D(boundsGTL.bottomRight().x(), boundsGTL.bottomRight().y()));
}
}
aiv3.aesTypeId(AesType::AtExplosionClusterGunToTargetLine);
aiv3.id(1000 * m_data.id + AesType::AtExplosionClusterGunToTargetLine);
// aiv3.effectStateId(effectState());
if (m_data.partyId != 0)
aiv3.partyId(m_data.partyId);
if (m_aivGunToTargetTrajectoryDirty || (aiv3 != m_aivGunToTargetTrajectory))
{
m_aivGunToTargetTrajectoryDirty = false;
m_aivGunToTargetTrajectory = aiv3;
aiv3.sampleTime(partitionTimeMSec()); // publish sampleTime, but do not store
m_mainHandler->dds()->dts()->publish(aiv3);
emit newAiv(aiv3);
}
}
else
{
auto dts = m_mainHandler->dds()->dts();
const bool errorMsgIfSampleDoesNotExists = false;
dts->removeAesItemViewByKey(1000 * m_data.id + AesType::AtExplosionClusterGunToTargetLine, errorMsgIfSampleDoesNotExists);
}
// if (!setupParticipantOrigin())
// ERROR_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " setupParticipantOrigin failed";
//--------------------------------
if (aiv != m_aiv)
{
m_aiv = aiv;
aiv.sampleTime(partitionTimeMSec()); // publish sampleTime, but do not store
m_mainHandler->dds()->dts()->publish(aiv);
emit newAiv(aiv);
}
// Don not publish ideal positions, wait for DetonationLocationReply
// Evtl. von m_mainHandler->dds()->cesFtc() abhaengig machen!?
// Trajectory will be generated later at checkNextSingleExplosion()
}
void ObjectExplosionCluster::removeTopics()
{
// Unfortunately removeTopics() will generate about 1000 ERROR_...
// Who knows a better way?
const auto &dts = m_mainHandler->dds()->dts();
const bool errorMsgIfSampleDoesNotExists = false;
dts->removeExplosionClusterByKey(m_data.id, errorMsgIfSampleDoesNotExists);
dts->removeAesItemViewByKey(1000 * m_data.id + AesType::AtExplosionCluster, errorMsgIfSampleDoesNotExists);
dts->removeAesItemViewByKey(1000 * m_data.id + AesType::AtExplosionClusterSingleExplosions, errorMsgIfSampleDoesNotExists);
dts->removeAesItemViewByKey(1000 * m_data.id + AesType::AtExplosionClusterGunToTargetLine, errorMsgIfSampleDoesNotExists);
// ti.id(1000 * m_data.id + AesType::AtExplosionClusterSingleExplosions);
dts->removeTriggeredImpactsByKey(1000 * m_data.id + AesType::AtExplosionClusterSingleExplosions, errorMsgIfSampleDoesNotExists);
#ifdef USE_TRAJECTORY_VIA_HANDLER
// remove TrajectoryTimeAware created via Handler:
// topicIds are stored at m_trajectoryHandlerExplosionIndexToTopicId
for (int topicId : qAsConst(m_trajectoryHandlerExplosionIndexToTopicId))
{
dts->removeTrajectoryTimeAwareByKey(topicId);
}
#else
// up to s_maxTrajectoriesPerExplosionCluster are supported. One sample per trajectory.
for (int explosionIndex = 0; explosionIndex < AreaEffectSimulation::s_maxTrajectoriesPerExplosionCluster; ++explosionIndex)
{
dts->removeAesItemViewByKey(1000 * m_data.id + 100 + explosionIndex, errorMsgIfSampleDoesNotExists);
}
#endif // USE_TRAJECTORY_VIA_HANDLER
// Effects / Impacts
// m_effects.id (1000 * m_data.id + AesType::AtExplosionClusterSingleExplosions)
dts->removeEffectsByKey(1000 * m_data.id + AesType::AtExplosionClusterSingleExplosions, errorMsgIfSampleDoesNotExists);
emit removeAiv(m_data.id);
}
// void ObjectExplosionCluster::startSingleExplosionHandling()
//{
// const qint64 impactDeltaMSecValue = impactDeltaMSec();
// DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " Starting explosion handling"
// << ", impactDeltaMSec = " << impactDeltaMSecValue;
// DUMP();
// if (!m_data.effectStart.isValid()) // 0 -> paused
// {
// // trim to second (really? yes since we can only enter seconds)
// m_data.effectStart = partitionTime();
// m_publishDataTimer->start();
// }
// m_singleExplosionTriggerTimer->setInterval(impactDeltaMSecValue);
// m_singleExplosionTriggerTimer->start();
// checkNextSingleExplosion(); // for second 0
//}
// void ObjectExplosionCluster::stopSingleExplosionHandling(AesEffectState newState)
//{
// m_singleExplosionTriggerTimer->stop();
// if (m_data.effectStateId != AesEffectState_def::EsActivated)
// return;
// // int chargeCountUntilLastStart = lrint((m_data.originalEffectDuration - m_data.effectDuration) / impactDeltaMSec());
// int chargeCountUntilLastStart = m_chargeCountUntilLastStart;
// qint64 msecsSinceLastStart = m_data.effectStart.msecsTo(partitionTime());
// int impactCount = m_data.impactCount;
// int curExplosionNumber = m_lastSentTriggeredExplosionNumber; // keep before modification !? Here -1 because we want to consume the proper amount of charge!
// if (curExplosionNumber > impactCount)
// curExplosionNumber = impactCount;
// DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " impactCount: " << impactCount;
// DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " chargeCountUntilLastStart: " << chargeCountUntilLastStart;
// DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " curExplosionNumber: " << curExplosionNumber;
// m_data.effectDuration -= msecsSinceLastStart;
// DEBUG_LOG(m_logger) << "stopSingleExplosionHandling: effectDuration = " << m_data.effectDuration;
// // ToDo
// if (newState == AesEffectState::EsExpired)
// {
// m_data.effectDuration = m_data.originalEffectDuration;
// m_data.effectStart = m_data.originalEffectStart;
// }
// Core::FunctionReplyObject ret = m_mainHandler->chargeAdministrationHandler()->consumeCharge(m_data.chargeTypeId,
// m_data.partyId,
// curExplosionNumber - chargeCountUntilLastStart);
// DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " Charge marked used in last lap: " << curExplosionNumber - chargeCountUntilLastStart;
// if (ret.error())
// ERROR_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " Could not consume Charge! " << ret();
// return; // avoid crash with sql_janitor ToDo: implement pause / resume
// // ToDo
// m_chargeCountUntilLastStart = curExplosionNumber;
// if (m_data.effectDuration < 0 || newState == AesEffectState::EsExpired)
// {
// DEBUG_LOG(m_logger) << "Expired!";
// m_data.effectDuration = m_data.originalEffectDuration;
// m_data.effectStart = m_data.originalEffectStart;
// }
// else // Paused
// m_data.effectStart = QDateTime(); // Invalid QDateTime to mark it paused
// m_publishDataTimer->start();
//}
void ObjectExplosionCluster::checkNextFire()
{
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " XXXXXXXXXXXXXXXXXXXX checkNextFire";
// For special purpose (db guez_241121)
// if (m_data.name.startsWith(QStringLiteral("SAAB")))
// return;
if (m_data.effectStateId == AreaEffectSimulation::AesEffectState_def::EsCreated)
{
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " OBJECT IS EsCreated, RETURN;";
return;
}
m_preStartTimer->stop();
// object should NOT be modified anymore:
if (m_temporaryData.isObjectModifiable)
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " OBJECT IS NOT Modifiable ANYMORE";
m_temporaryData.isObjectModifiable = false;
onPublishData();
if (isVulcano())
{
// copy data from GTL:
// const TracjectoryData tdRefGTL = m_trajectoryCont[-1];
// TracjectoryData &tdRefDest = m_trajectoryCont[0];
// // // tdRefDest.index
// tdRefDest.peakHeightAbs = tdRefGTL.peakHeightAbs;
// tdRefDest.trajectoryGeometry = tdRefGTL.trajectoryGeometry;
// tdRefDest.trajectoryTimeAware = tdRefGTL.trajectoryTimeAware;
const TrajectoryGeneratorVulcano::Options opts = TrajectoryGeneratorVulcano::OptRasterApoTap | TrajectoryGeneratorVulcano::OptIncludeIdealHit
// | TrajectoryGeneratorVulcano::OptRasterTapHit
;
QString reasonOutCheckNextFire;
generateTrajectoryVulcanoSpecific(1, opts, &reasonOutCheckNextFire); // 1 == explosionNumber
if (!reasonOutCheckNextFire.isEmpty())
ERROR_LOG(m_logger) << " " << m_data.id << " reasonOutCheckNextFire=" << reasonOutCheckNextFire;
publishTrajectory(0);
}
else
{
// real work:
QElapsedTimer elapsedTimer;
elapsedTimer.start();
// const int impactCount = m_data.impactCount;
// for (int explosionNumber=1; explosionNumber<=impactCount; ++explosionNumber) // explosionNumber start with '1'
// generateTrajectory(explosionNumber);
// DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " generateTrajectory for all (" << impactCount << ")"
// << " took " << elapsedTimer.elapsed() << " [ms]";
}
DUMP();
{
const bool initSuccess = m_firingTimer.init(m_data.effectDuration, m_data.impactCount, m_temporaryData.calculatedFlightDurationMsec);
if (!initSuccess)
ERROR_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " firingTimer.init() failed";
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " firingTimer.init() initSuccess " << initSuccess;
const qint64 delay = activationTime().toMSecsSinceEpoch() - m_temporaryData.calculatedFlightDurationMsec - partitionTimeMSec();
if (noTracjectoryRequired())
{
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " startFiring (no delay)";
// // connect(&m_firingTimer, &FiringTimer::firing, this, &ObjectExplosionCluster::onFiringTimerFiring, Qt::UniqueConnection);
connect(&m_firingTimer, &FiringTimer::impact, this, &ObjectExplosionCluster::onFiringTimerImpact, Qt::UniqueConnection);
// // connect(&m_firingTimer, &FiringTimer::stateChangeDelayedAsInt,
// // this, &ObjectExplosionCluster::onFiringTimerStateChangeDelayedCommandAsInt, Qt::UniqueConnection);
m_firingTimer.startFiring();
}
else
{
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " trigger startFiringDelay, delay " << delay;
connect(&m_firingTimer, &FiringTimer::firing, this, &ObjectExplosionCluster::onFiringTimerFiring, Qt::UniqueConnection);
connect(&m_firingTimer, &FiringTimer::impact, this, &ObjectExplosionCluster::onFiringTimerImpact, Qt::UniqueConnection);
connect(&m_firingTimer, &FiringTimer::stateChangeDelayedAsInt, this, &ObjectExplosionCluster::onFiringTimerStateChangeDelayedCommandAsInt, Qt::UniqueConnection);
m_firingTimer.startFiringDelay(delay);
}
}
}
//// called every second
// void ObjectExplosionCluster::checkNextSingleExplosion()
//{
// return;
// const int curExplosionNumber = currentExplosionNumber();
// const int impactCount = m_data.impactCount;
// if (curExplosionNumber > impactCount)
// {
// DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " Remaining effect duration is zero - no more single explosions"
// << ", curExplosionNumber = " << curExplosionNumber
// << ", impactCount = " << impactCount
// << ", m_lastSentTriggeredExplosionNumber = " << m_lastSentTriggeredExplosionNumber;
// m_singleExplosionTriggerTimer->stop();
// m_data.effectDuration = m_data.originalEffectDuration;
// m_data.effectStart = m_data.originalEffectStart;
// m_publishDataTimer->start();
// }
// else
// {
// // check if a new explosion is triggered
// if (curExplosionNumber == m_lastSentTriggeredExplosionNumber)
// return; // nothing changed -> do not publish anything
// m_lastSentTriggeredExplosionNumber = curExplosionNumber;
// DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " checkNextSingleExplosion: curExplosionNumber = " << curExplosionNumber;
// DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " checkNextSingleExplosion: m_lastSentTriggeredExplosionNumber = " << m_lastSentTriggeredExplosionNumber;
// // publish new triggered explosions data here
// // moved to onDetonationLocationReply
// const int curExplosionIndex = curExplosionNumber-1;
// // Effects:
// std::vector<AreaEffectSimulation::SingleEffect> &singleEffectsRef = m_effects.singleEffects();
// if (singleEffectsRef.empty())
// {
// WARNING_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " singleEffectsRef empty, curExplosionNumber" << curExplosionNumber;
// }
// else
// {
// bool bChanged = false;
// const qint64 curPartTime = partitionTimeMSec();
// for(int idx = 0; idx <= curExplosionIndex; ++idx) // idx !! <= !! curExplosionIndex
// {
// if (idx >= static_cast<int>(singleEffectsRef.size()))
// continue;
// SingleEffect &ref = singleEffectsRef[idx];
// if (ref.singleEffectState().underlying() != AesSingleEffectState_def::SesTriggered)
// {
// ref.singleEffectState(AesSingleEffectState_def::SesTriggered);
// ref.singleEffectTime(curPartTime);
// bChanged = true;
// }
// } // for
// if (bChanged)
// {
// m_effects.sampleTime(curPartTime);
// m_mainHandler->dds()->dts()->publish(m_effects);
// }
// } // if (singleEffectsRef.empty())
// }
//}
void ObjectExplosionCluster::onFiringTimerFiring(int currentFiringNumber, int totalAmmoCount)
{
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " currentFiringNumber = " << currentFiringNumber << " totalAmmoCount = " << totalAmmoCount;
Core::FunctionReplyObject ret = m_mainHandler->chargeAdministrationHandler()->consumeCharge(m_data.chargeTypeId, m_data.partyId, 1);
if (ret.error())
WARNING_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " consumeCharge failed: " << ret.translated();
generateTrajectory(currentFiringNumber);
}
void ObjectExplosionCluster::onFiringTimerImpact(int currentExplosionNumber, int totalAmmoCount)
{
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " currentExplosionNumber = " << currentExplosionNumber << " totalAmmoCount = " << totalAmmoCount;
m_lastSentTriggeredExplosionNumber = currentExplosionNumber;
const int curExplosionIndex = currentExplosionNumber - 1;
// Effects:
std::vector<AreaEffectSimulation::SingleEffect> &singleEffectsRef = m_effects.singleEffects();
if (singleEffectsRef.empty())
{
WARNING_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " singleEffectsRef empty, currentExplosionNumber" << currentExplosionNumber;
}
else
{
bool bChanged = false;
const qint64 curPartTime = partitionTimeMSec();
for (int idx = 0; idx <= curExplosionIndex; ++idx) // idx !! <= !! curExplosionIndex
{
if (idx >= static_cast<int>(singleEffectsRef.size()))
continue;
SingleEffect &ref = singleEffectsRef[idx];
if (ref.singleEffectState().underlying() != AesSingleEffectState_def::SesTriggered)
{
ref.singleEffectState(AesSingleEffectState_def::SesTriggered);
ref.singleEffectTime(curPartTime);
bChanged = true;
}
} // for
if (bChanged)
{
m_effects.sampleTime(curPartTime);
m_mainHandler->dds()->dts()->publish(m_effects);
}
} // if (singleEffectsRef.empty())
}
void ObjectExplosionCluster::onFiringTimerStateChangeDelayedCommandAsInt(int cmdAsInt, int firedAmmoCount)
{
const FiringTimer::CMD cmd = static_cast<FiringTimer::CMD>(cmdAsInt);
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " got signal stateChangeDelayed, delay " << cmd << ", firedAmmoCount = " << firedAmmoCount;
// if (effectState() != AesEffectState::EsPrepared &&
// effectState() != AesEffectState::EsPaused)
// {
// DEBUG_LOG(m_logger) << id() << " trySwitchToActivated failed - not prepared/paused: " << effectState();
// return false;
// }
// if (!isActivationTimeReached())
// {
// DEBUG_LOG(m_logger) << id() << " trySwitchToActivated failed - activation time not reached: "
// << isActivationTimeSet() << " - " << time(nullptr) << " - " << activationTime().toSecsSinceEpoch();
// return false;
// }
// DEBUG_LOG(m_logger) << id() << " trySwitchToActivated succeeded";
// setEffectState(AesEffectState::EsActivated);
// return true;
AesEffectState newState = AesEffectState_def::EsUnknown;
switch (cmd)
{
case FiringTimer::CMD::CMD_START:
case FiringTimer::CMD::CMD_RESUME:
newState = AesEffectState_def::EsActivated;
m_data.effectStart = partitionTime();
break;
case FiringTimer::CMD::CMD_PAUSE:
{
newState = AesEffectState_def::EsPaused;
m_data.effectStart = QDateTime(); // Invalid QDateTime to mark it paused
//
// update remaining:
//
// calculate remaining duration:
if (firedAmmoCount >= 0)
{
const int remainingAmmoCount = m_data.impactCount - firedAmmoCount;
m_data.remainExplosionNumber = firedAmmoCount + 1; // more like _NEXT_ ExplosionNumber
m_data.effectDuration = remainingAmmoCount * m_firingTimer.intervallMsec();
}
// keep in mind:
// from .../Lts/Proxies/TrainingAreaBase/recv_from_dds_aes.cpp:
// int getSequelNumber(int startSequelNumber, int impactCount, qint64 originalEffectDurationMs, qint64 effectDurationMs)
// {
// const double delta_t = double(originalEffectDurationMs) / impactCount; // msecs between impacts
// const int impactsTriggered = impactCount - qRound(effectDurationMs / delta_t);
// for (int i = 1; i < impactsTriggered; ++i)
// startSequelNumber = (Math::AZ * startSequelNumber + Math::CZ) % Math::MZ;
// return startSequelNumber;
// }
// : calculate consumed duration
}
break;
case FiringTimer::CMD::CMD_EXPIRED_PLUS:
newState = AesEffectState_def::EsExpired;
DEBUG_LOG(m_logger) << "Expired!";
m_data.effectDuration = m_data.originalEffectDuration;
m_data.effectStart = m_data.originalEffectStart;
break;
case FiringTimer::CMD::CMD_UNDEFINED:
case FiringTimer::CMD::CMD_EXPIRED:
// noop
break;
} // switch
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " got signal stateChangeDelayed, setNewState " << newState
<< ", m_data.effectDuration = " << m_data.effectDuration << ", m_data.remainExplosionNumber (nextExplosion) = " << m_data.remainExplosionNumber;
if (newState != AesEffectState_def::EsUnknown)
setEffectState(newState);
}
double ObjectExplosionCluster::getElevationFor(const QPointF &originGeoRadiant, const QString &context) const
{
static LtsElevation::LtsElevationManager *eleMgr = nullptr;
if (!eleMgr)
eleMgr = getTrajectoryInstance(m_mainHandler)->getElevationManager();
double zValue = s_defaultZ_Value; // default Elevation for GUEZ / Altmark. Hopefully fine for other areas..
if (eleMgr)
zValue = eleMgr->elevation(originGeoRadiant.x(), originGeoRadiant.y()); // double lon_rad, double lat_rad
else
{
WARNING_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " no ElevationManager, assuming '100', context='" << context << "'"
<< " zValue= " << zValue;
}
if (zValue < -300)
{
WARNING_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " elevation for originGeoRadiant '" << originGeoRadiant << "' is really small: " << zValue
<< ", assuming '100', context='" << context << "'";
zValue = s_defaultZ_Value;
}
return zValue;
}
bool ObjectExplosionCluster::generateTrajectory(int explosionNumber, bool startDetonationLocationRequest, QString *reasonOut)
{
// generate Trajectory:
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " START generate Trajectory: explosionNumber = " << explosionNumber
<< ", startDetonationLocationRequest=" << startDetonationLocationRequest;
// Q_ASSERT(isVulcano() == false);
const int zoneOfImpactCoord = LtsCoordTrans::UtmCoordinate::fromGeographic(m_data.impactPosition).zone;
QPointF endPosition_geo2D;
const int explosionIndex = explosionNumber - 1;
bool bIsGunToTargetPreview = false;
if (explosionNumber <= 0)
{
bIsGunToTargetPreview = true;
// center of target:
endPosition_geo2D = AreaEffectSimulation::Polygons::bottomLeft2CenterPoint(m_data.impactPosition, m_data.impactWidth, m_data.impactLength, m_data.rotationAngle);
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " *** generateTrajectory to: center"
<< ", endPosition_geo2D = " << endPosition_geo2D;
}
else
{
// take impactPosition from form:
const std::vector<Core::GeoPosition> &formRef = m_aiv2.form();
Q_ASSERT(formRef.size() > 0);
Q_ASSERT(explosionIndex >= 0);
const Core::GeoPosition &impactPosition_geo3D = formRef[explosionIndex];
endPosition_geo2D = QPointF(impactPosition_geo3D.lon(), impactPosition_geo3D.lat());
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " *** generateTrajectory to: explosionIndex=" << explosionIndex
<< ", endPosition_geo2D = " << endPosition_geo2D;
}
// generate 'ideal' trajectory geometry, will be adjusted via reply and adjustTrajectoryToDetonationLocation
// save to m_trajectoryCont:
TracjectoryData &tdRef = m_trajectoryCont[explosionIndex];
tdRef.index = explosionIndex;
// reduce input values
// in: a) explosionCluster.peakHeight
// b) explosionCluster.flightDuration[msec] and LowOrHigh
// reduce to angle: to support generateTrajectoryBiedziak
const LtsCoordTrans::UtmCoordinate &endPosUtm = LtsCoordTrans::UtmCoordinate::fromGeographic(endPosition_geo2D, zoneOfImpactCoord);
// add z-Value:
const double zValue = getElevationFor(m_data.impactPosition, QString(QStringLiteral("impactPosition_explosionIndex_%1")).arg(explosionIndex));
const LtsUtils::QPoint3D endPosUtmPoint3D = LtsUtils::QPoint3D(endPosUtm.x, endPosUtm.y, zValue);
double betaRadiant = 0; // elevation_angle_degree
double vOut = 0;
bool success = true;
QString reason, reasonTraj;
// firingOrigin.... should have an absolute zValue:
// which cannon?
LtsUtils::QPoint3D firingOriginGeoPoint3D;
LtsUtils::QPoint3D firingOriginUtmPoint3D;
if (bIsGunToTargetPreview)
{
firingOriginGeoPoint3D = m_data.firingCenterPosition;
firingOriginUtmPoint3D = m_temporaryData.m_firingUnitOriginUtmPoint3D;
}
else
{
firingOriginGeoPoint3D = getFiringCannonGeoPosition(explosionIndex);
firingOriginUtmPoint3D = getFiringCannonUtmPosition(explosionIndex, zoneOfImpactCoord);
}
// Which data is given by user? UI::peakHeight is relative to firingPosition.z()
if (m_data.peakHeight > 0)
{
tdRef.peakHeightAbs = m_temporaryData.m_firingUnitOriginUtmPoint3D.z() + m_data.peakHeight; // checked: GUEZE-2310
// For flightDurationSec the center should be used. (FlightDuration should be identical for all trajectories
tdRef.flightDurationMSec
= TrajectoryHelper::flightDurationSec(m_temporaryData.m_firingUnitOriginUtmPoint3D, endPosUtmPoint3D, tdRef.peakHeightAbs, &betaRadiant, &vOut, &reasonTraj)
* 1000;
if (tdRef.flightDurationMSec <= 0 || !reasonTraj.isEmpty())
{
ERROR_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << ", got flightDurationSecError: "
<< ", explosionIndex=" << explosionIndex << ", m_temporaryData.m_firingUnitOriginUtmPoint3D = " << m_temporaryData.m_firingUnitOriginUtmPoint3D
<< ", m_data.peakHeight (relToFiring) " << m_data.peakHeight << ", tdRef.peakHeightAbs " << tdRef.peakHeightAbs
<< ", endPosUtmPoint3D = " << endPosUtmPoint3D;
success = false;
reason = QString(QStringLiteral("(flightDurationSecError (%1;%2))")).arg(tdRef.flightDurationMSec).arg(reasonTraj);
}
}
else if (m_data.flightDuration > 0)
{
tdRef.flightDurationMSec = m_data.flightDuration;
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << ", isAirSupportSource = " << m_isAirSupportSource;
if (m_isAirSupportSource)
{
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << ", endPosUtmPoint3D = " << endPosUtmPoint3D;
// NASAT: firingCenterPosition is position of AirCraft, means apogaeum:
const LtsCoordTrans::UtmCoordinate &firingOriginUtm = LtsCoordTrans::UtmCoordinate::fromGeographic(m_data.firingCenterPosition.toPointF(), zoneOfImpactCoord);
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << ", peak==NASAT = " << firingOriginUtm;
const LtsUtils::QPoint3D apogaeum(firingOriginUtm.x, firingOriginUtm.y, m_data.firingCenterPosition.z());
const LtsUtils::QPoint3D endPoint3D = endPosUtmPoint3D;
const LtsUtils::QPoint3D realStartPointUTM = TrajectoryHelper::realStartPoint(apogaeum, endPoint3D);
// and now let that be used for Trajectory...:
{
LtsCoordTrans::UtmCoordinate temp(zoneOfImpactCoord, realStartPointUTM.x(), realStartPointUTM.y());
QPointF tempGeo = temp.geographic();
firingOriginUtmPoint3D = realStartPointUTM;
firingOriginGeoPoint3D = LtsUtils::QPoint3D(tempGeo.x(), tempGeo.y(), realStartPointUTM.z());
}
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << ", XXXXX endPoint3D = " << endPoint3D << ", apogaeum = " << apogaeum
<< ", realStartPointUTM = " << realStartPointUTM;
}
tdRef.peakHeightAbs
= TrajectoryHelper::peakHeightAbs(firingOriginUtmPoint3D, endPosUtmPoint3D, m_data.flightDuration / 1000.0, /*trajectoryMode,*/ &betaRadiant, &vOut, &reasonTraj);
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << ", XXXXX tdRef.peakHeightAbs = " << tdRef.peakHeightAbs;
if ((tdRef.peakHeightAbs < -1000) || (tdRef.peakHeightAbs > 400000) || !reasonTraj.isEmpty()) // Beginn der Atmosphaere: 400-700km
{
success = false;
reason = QString(QStringLiteral("(peakHeightAbs outOfRange (%1))")).arg(reasonTraj);
ERROR_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << ", got peakHeight with error: "
<< ", reason ='" << reason << "'"
<< ", explosionIndex=" << explosionIndex << ", m_data.peakHeight (relToFiring) " << m_data.peakHeight
<< ", m_firingUnitOriginUtmPoint3D = " << m_temporaryData.m_firingUnitOriginUtmPoint3D << ", endPosUtmPoint3D = " << endPosUtmPoint3D;
}
} // if (m_data.peakHeight > 0)
if (bIsGunToTargetPreview)
{
m_temporaryData.calculatedFiringSpeed = vOut;
m_temporaryData.calculatedFlightDurationMsec = tdRef.flightDurationMSec;
m_temporaryData.calculatedPeakHeightAbs = tdRef.peakHeightAbs;
{
// calculate mhpRotation using UTM and identical zone!
m_temporaryData.calculatedMhpRotationNorthDeg = getAngleDegreeNorth(m_temporaryData.m_firingUnitOriginUtmPoint3D.toPointF(), endPosUtmPoint3D.toPointF());
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << ", angleDegreeNorth = " << m_temporaryData.calculatedMhpRotationNorthDeg;
}
}
if (success)
{
const double elevation_angle_degree = betaRadiant * LtsCoordTrans::rad2deg();
if ((elevation_angle_degree < 0) || (elevation_angle_degree > 90))
{
success = false;
reason += QString(QStringLiteral("(elevation_angle_degree outOfRange (%1))")).arg(elevation_angle_degree);
}
if (success)
{
m_temporaryData.calculatedFiringAngle = elevation_angle_degree;
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " XXXXX explosionIndex=" << explosionIndex << ", firingOriginGeoPoint3D " << firingOriginGeoPoint3D
<< ", firingOriginUtmPoint3D " << firingOriginUtmPoint3D << ", m_data.peakHeight (relToFiring) " << m_data.peakHeight
<< ", tdRef.peakHeightAbs " << tdRef.peakHeightAbs << ", m_data.flightDuration=" << m_data.flightDuration
<< ", endPosUtmPoint3D = " << endPosUtmPoint3D << " -> tdRef.flightDurationMSec = " << tdRef.flightDurationMSec
<< ", elevation_angle_degree = " << elevation_angle_degree << ", vOut = " << vOut;
// create data in place (tdRef.trajectoryGeometry)
static TrajectoryGenerator *trajectoryGenerator = getTrajectoryInstance(m_mainHandler);
success = trajectoryGenerator->generateTrajectoryBiedziak(firingOriginGeoPoint3D,
LtsUtils::QPoint3D(endPosition_geo2D.x(), endPosition_geo2D.y(), zValue),
elevation_angle_degree,
tdRef.trajectoryGeometry);
// for NASAT wa can remove first half:
if (m_isAirSupportSource)
{
// Note: tdRef.trajectoryGeometry is not time-aware
// not really nice but: since pop_front is not available create a temorary partial copy;
// avoid start in den back of the AirCraft
std::vector<Core::GeoPosition> trajectoryGeometrySecondHalf(tdRef.trajectoryGeometry.begin() + (tdRef.trajectoryGeometry.size() / 2.0),
tdRef.trajectoryGeometry.end());
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " XXXXX explosionIndex=" << explosionIndex << " tdRef.trajectoryGeometry.size"
<< tdRef.trajectoryGeometry.size() << " tdRef.trajectoryGeometrySecondHalf.size" << trajectoryGeometrySecondHalf.size();
tdRef.trajectoryGeometry = trajectoryGeometrySecondHalf;
}
if (!success)
{
ERROR_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " ERROR *** trajectoryGenerator->generateTrajectory failed, explosionIndex=" << explosionIndex;
reason += QStringLiteral("(generateTrajectory failed)");
}
Core::GeoPosition first;
if (!tdRef.trajectoryGeometry.empty())
first = tdRef.trajectoryGeometry.front();
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " *** generateTrajectory, explosionIndex=" << explosionIndex << " DONE"
<< ", trajectory.size = " << tdRef.trajectoryGeometry.size() << ", first = " << first;
if (startDetonationLocationRequest)
{
// Schnittpunktberechnung nur bei bei zentralen Wirkfeldern
if (m_data.isCentral)
{
// start DetonationLocation request
const DetonationLocationRequest &request = detonationLocationRequest(explosionIndex);
m_mainHandler->dds()->cesFtc()->detonationLocationRequest(request, this);
}
else
{
DetonationLocationReply reply;
reply.id(m_data.id);
reply.index(explosionIndex);
// reply.position(); // leave on default :-)
onDetonationLocationReply(reply);
}
// reply is processed at onDetonationLocationReply
}
} // if (success)
} // if (success)
if (reasonOut)
*reasonOut = reason;
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " END generate Trajectory: explosionNumber = " << explosionNumber
<< ", startDetonationLocationRequest=" << startDetonationLocationRequest;
return success;
}
bool ObjectExplosionCluster::generateTrajectoryVulcanoSpecific(int explosionNumber, const TrajectoryGeneratorVulcano::Options options, QString *reasonOut)
{
// const int zoneOfImpactCoord = LtsCoordTrans::UtmCoordinate::fromGeographic(m_data.impactPosition).zone;
const int explosionIndex = explosionNumber - 1;
const bool bIsGunToTargetPreview = true;
// center of target:
const QPointF &endPosition_geo2D
= AreaEffectSimulation::Polygons::bottomLeft2CenterPoint(m_data.impactPosition, m_data.impactWidth, m_data.impactLength, m_data.rotationAngle);
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " *** generateTrajectory to: center"
<< ", endPosition_geo2D = " << endPosition_geo2D << ", explosionNumber=" << explosionNumber;
// save to m_trajectoryCont:
TracjectoryData &tdRef = m_trajectoryCont[explosionIndex];
tdRef.index = explosionIndex;
// which cannon?
LtsUtils::QPoint3D firingOriginGeoPoint3D;
// LtsUtils::QPoint3D firingOriginUtmPoint3D;
if (bIsGunToTargetPreview)
{
firingOriginGeoPoint3D = m_data.firingCenterPosition;
// firingOriginUtmPoint3D = m_temporaryData.m_firingUnitOriginUtmPoint3D;
}
else
{
firingOriginGeoPoint3D = getFiringCannonGeoPosition(explosionIndex);
// firingOriginUtmPoint3D = getFiringCannonUtmPosition(explosionIndex, zoneOfImpactCoord);
}
bool success = false;
QString localReasonOut;
// Which data is given by user? UI::peakHeight is relative to firingPosition.z()
if (m_data.peakHeight > 0)
{
const double v0 = TrajectoryGeneratorVulcano::defaultv0();
const double peakHeightRelToOrigin = m_data.peakHeight;
const double betaRad = XY::calculateBetaRad(v0, peakHeightRelToOrigin, &localReasonOut);
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " START" << " id/name= '" << m_data.name << "'/" << m_data.id << " IS_VULCANO = "
<< " betaDeg " << betaRad * LtsCoordTrans::rad2deg();
if (!localReasonOut.isEmpty())
{
ERROR_LOG(m_logger) << "generateTrajectoryVulcano failed, localReasonOut = " << localReasonOut;
if (reasonOut)
*reasonOut = localReasonOut;
return false;
}
const double alphaRad = m_data.dropAngle * LtsCoordTrans::deg2rad();
const double tapTime = TrajectoryGeneratorVulcano::defaultTapTimeSec();
m_data.launchAngleDeg = betaRad * LtsCoordTrans::rad2deg();
// const TrajectoryGeneratorVulcano::Options opts =
// TrajectoryGeneratorVulcano::OptRasterApoTap |
// TrajectoryGeneratorVulcano::OptIncludeIdealHit |
// TrajectoryGeneratorVulcano::OptRasterTapHit;
const QPoint3D &originatorPosition_geo = firingOriginGeoPoint3D;
// add z-Value:
const double zValue = getElevationFor(m_data.impactPosition, QString(QStringLiteral("impactPosition_explosionIndex_%1")).arg(explosionIndex));
const QPoint3D idealHit_geo(endPosition_geo2D.x(), endPosition_geo2D.y(), zValue);
static TrajectoryGenerator *trajectoryGenerator = getTrajectoryInstance(m_mainHandler);
Core::GeoPosition idealTapAbsoluteGeoOut;
success = trajectoryGenerator->generateTrajectoryVulcano(originatorPosition_geo,
idealHit_geo,
v0,
betaRad,
alphaRad,
tapTime,
options,
tdRef.trajectoryTimeAware.geometry(),
idealTapAbsoluteGeoOut,
&localReasonOut);
if (!localReasonOut.isEmpty())
{
ERROR_LOG(m_logger) << "generateTrajectoryVulcano failed, localReasonOut = " << localReasonOut;
if (reasonOut)
*reasonOut = localReasonOut;
return false;
}
if (!success)
{
ERROR_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " START" << " id/name= '" << m_data.name << "'/" << m_data.id
<< " trajectoryGenerator->generateTrajectoryVulcano failed";
if (reasonOut)
*reasonOut = localReasonOut;
return false;
}
DEBUG_LOG(m_logger) << " cloudBase modification = " << m_data.cloudBase;
// honor cloudBase if valid:
if (m_data.cloudBase > std::numeric_limits<int>::min())
{
// get access to point tapT:
std::vector<Core::GeoPositionRelativeTime> &geometryRef = tdRef.trajectoryTimeAware.geometry();
std::vector<Core::GeoPositionRelativeTime>::reverse_iterator rit = geometryRef.rbegin();
const Core::GeoPositionRelativeTime impact = *rit;
// one step to point to tapT
++rit;
const Core::GeoPositionRelativeTime tapT = *rit;
const bool bTapT_strichRequested = (m_data.cloudBase < tapT.z()) && (impact.z() < m_data.cloudBase);
ERROR_LOG(m_logger) << " XXX cloudBase modification: "
<< ", tapT = " << tapT << ", m_data.cloudBase = " << m_data.cloudBase << ", impact = " << impact
<< ", bTapT_strichRequested = " << bTapT_strichRequested;
if (bTapT_strichRequested)
{
const LtsCoordTrans::UtmCoordinate impactUtm = LtsCoordTrans::UtmCoordinate::fromGeographic(impact.lon(), impact.lat());
const LtsCoordTrans::UtmCoordinate tapTUtm = LtsCoordTrans::UtmCoordinate::fromGeographic(tapT.lon(), tapT.lat(), impactUtm.zone);
const QVector3D impactVec3D(impactUtm.x, impactUtm.y, impact.z());
const QVector3D tapTVec3D(tapTUtm.x, tapTUtm.y, tapT.z());
/* x | Tap (aka TapT)
// \ |
// \ |
// \ |
// \ |
// -------x | CloudBase (Tap_strich)
// \ |
// \ |
// ----------x | Impact
//
// ----------------| Surface
*/
// Geometry
// aus Sicht von Impact
QVector3D offset = tapTVec3D - impactVec3D;
const double offset_z = offset.z();
const double scaleFactor = (static_cast<double>(m_data.cloudBase) - impactVec3D.z()) / offset_z;
const QVector3D scaledOffset = offset * scaleFactor;
const QVector3D tapT_strich = impactVec3D + scaledOffset;
// DEBUG_LOG(m_logger) << " offset_z " << offset_z;
// DEBUG_LOG(m_logger) << " scaleFactor " << scaleFactor;
// DEBUG_LOG(m_logger) << " scaledOffset " << scaledOffset;
// DEBUG_LOG(m_logger) << " tapTVec3D " << tapTVec3D;
// DEBUG_LOG(m_logger) << " offset " << offset;
// DEBUG_LOG(m_logger) << " tapT_strich " << tapT_strich;
// DEBUG_LOG(m_logger) << " impactVec3D " << impactVec3D;
const LtsCoordTrans::UtmCoordinate tapT_strichUtm(impactUtm.zone, tapT_strich.x(), tapT_strich.y());
const QPointF &tapT_strichGeo = tapT_strichUtm.geographic();
// Time
double timeOffset = impact.relativeTime() - tapT.relativeTime();
timeOffset *= scaleFactor;
Core::GeoPositionRelativeTime tapT_strichRelTime;
tapT_strichRelTime.lon() = tapT_strichGeo.x();
tapT_strichRelTime.lat() = tapT_strichGeo.y();
tapT_strichRelTime.z() = tapT_strich.z();
tapT_strichRelTime.relativeTime(impact.relativeTime() - timeOffset);
DEBUG_LOG(m_logger) << " tapT_strichRelTime " << tapT_strichRelTime;
// (.. n-4, n-3, n-2, n-1, n)
// ^
// Inserts value before pos:
auto it = geometryRef.end();
geometryRef.insert(--it, tapT_strichRelTime);
}
}
// "convert" from time-aware curve 'back' to time-unaware trajectoryGeometry
tdRef.trajectoryGeometry.clear();
for (const Core::GeoPositionRelativeTime &geoPosRelTime : qAsConst(tdRef.trajectoryTimeAware.geometry()))
tdRef.trajectoryGeometry.emplace_back(geoPosRelTime); // implicit // downcast
tdRef.peakHeightAbs = peakHeightRelToOrigin + originatorPosition_geo.z();
}
else
{
// For vulcano, peakHeight is required, not optional
localReasonOut = QString(QStringLiteral("peakHeight is invalid (%1)")).arg(m_data.peakHeight);
ERROR_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " START" << " id/name= '" << m_data.name << "'/" << m_data.id << " no peakHeight";
}
if (reasonOut)
*reasonOut = localReasonOut;
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " END generate Trajectory: explosionNumber = " << explosionNumber;
return success;
}
bool ObjectExplosionCluster::getFiringUnitOrigin(const int firingParticipantId, LtsUtils::QPoint3D &firingOriginOut, QString *reasonOut)
{
// firingParticipantId is Feuereinheit/GeschuetzStellung
TRACE_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " START, firingParticipantId = " << firingParticipantId;
QString reason;
if (firingParticipantId <= 0)
{
ERROR_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << ", participantId invalid: " << firingParticipantId;
reason = QString(QStringLiteral("firingParticipantId is invalid (%1)")).arg(firingParticipantId);
if (reasonOut)
*reasonOut = reason;
return false;
}
std::shared_ptr<ParticipantManagement::Interface::Dtc> ppmDtc = m_mainHandler->dds()->ppmDtc();
if (!ppmDtc)
{
ERROR_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << ", ERROR, no ppmDtc";
reason = QString(QStringLiteral("firingParticipantId not found (%1)")).arg(firingParticipantId);
if (reasonOut)
*reasonOut = reason;
return false;
}
const bool isLeaf = ppmDtc->participant(firingParticipantId).inferiorIds().empty(); // isLeaf means single (Participant and not a Unit)
if (isLeaf)
{
const ParticipantManagement::ParticipantPosition &partPos = ppmDtc->participantPosition(firingParticipantId);
if (partPos.participantId() != firingParticipantId)
return false;
// relative zValue -> absolute zValue:
// Keep NASAT in mind sending 'height' via NasatPosition (normally, 'height' is relative to ground)
const double zValue = getElevationFor({partPos.pos().lon(), partPos.pos().lat()}, QString(QStringLiteral("participantPosition_partId=%1")).arg(firingParticipantId));
firingOriginOut = LtsUtils::QPoint3D(partPos.pos().lon(), partPos.pos().lat(), partPos.pos().z() + zValue);
}
else
{
// See also [GUEZE-2309]
// Using the ppmDtc->unitPosition has some drawbacks:
// The PPM::UnitPositionCalculator ignore outdated positions
// So in case of Replay/Snapshot/Restart of SV-SW the resulting position may differ
// So calculate on our own:
// const ParticipantManagement::UnitPosition &unitPos = ppmDtc->unitPosition(firingParticipantId);
// if (unitPos.participantId() != firingParticipantId)
// return false;
firingOriginOut
= Polygons::calculateFiringUnitCenterNonRecursive(m_mainHandler->dds()->ppmDtc(), firingParticipantId, m_temporaryData.singleFiringPositions, m_logger);
// set z-Value:
int idx = 0;
for (Core::GeoPosition &geoPosRef : m_temporaryData.singleFiringPositions)
{
const double zValue = getElevationFor({geoPosRef.lon(), geoPosRef.lat()}, QString(QStringLiteral("firingCannonPosition_index_%1")).arg(idx++));
geoPosRef.z(zValue);
}
if (m_logger.isDebugEnabled())
for (const Core::GeoPosition geoPosRef : m_temporaryData.singleFiringPositions)
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " singleFiringPositions = " << geoPosRef;
}
// and some checks:
if (std::isnan(firingOriginOut.x()) || std::isnan(firingOriginOut.y()))
{
ERROR_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " invalid position for firingParticipantId = " << firingParticipantId << ", firingOrigin is NaN";
reason = QString(QStringLiteral("firingParticipantId '%1' has invalid position (NaN)")).arg(firingParticipantId);
if (reasonOut)
*reasonOut = reason;
return false;
}
if (qFuzzyIsNull(firingOriginOut.x()) || qFuzzyIsNull(firingOriginOut.y()))
{
ERROR_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " invalid position for firingParticipantId = " << firingParticipantId << ", firingOrigin is 0";
reason = QString(QStringLiteral("firingParticipantId '%1' has invalid position (0,0)")).arg(firingParticipantId);
if (reasonOut)
*reasonOut = reason;
return false;
}
// const double zValue = getElevationFor(firingOriginOut.toPointF(), QString(QStringLiteral("firingParticipantId%1")).arg(firingParticipantId));
// firingOriginOut.setZ(zValue);
// check provided zValue; add elevation if neccessary:
// (e.g. NASAT aircrafts are already having a valid zValue, do not overwrite)
double zValue = firingOriginOut.z();
if (std::isnan(zValue) || qFuzzyIsNull(zValue))
{
zValue = getElevationFor(firingOriginOut.toPointF(), QString(QStringLiteral("firingParticipantId%1")).arg(firingParticipantId));
firingOriginOut.setZ(zValue);
}
m_temporaryData.m_firingUnitOriginUtm = LtsCoordTrans::UtmCoordinate::fromGeographic(firingOriginOut.toPointF());
m_temporaryData.m_firingUnitOriginUtmPoint3D = LtsUtils::QPoint3D(m_temporaryData.m_firingUnitOriginUtm.x, m_temporaryData.m_firingUnitOriginUtm.y, zValue);
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " END, firingParticipantId = " << firingParticipantId << ", firingOriginOut = " << firingOriginOut
<< ", m_firingUnitOriginUtm = " << m_temporaryData.m_firingUnitOriginUtm.mgrs()
<< ", m_firingUnitOriginUtmPoint3D = " << m_temporaryData.m_firingUnitOriginUtmPoint3D;
return true;
}
bool ObjectExplosionCluster::firingOriginIsValid(const LtsUtils::QPoint3D &firingOrigin, QString *reasonOut) const
{
TRACE_LOG(m_logger) << LOGFUNCTION << " START, originatorOrigin=" << firingOrigin;
// check if valid
// Maybe in future we will check also the distance to the target
if (std::isnan(firingOrigin.x()) || std::isnan(firingOrigin.y()) || std::isnan(firingOrigin.z()))
{
if (reasonOut)
*reasonOut = QStringLiteral("originatorOrigin isNaN");
TRACE_LOG(m_logger) << LOGFUNCTION << " END, originatorOrigin isNaN, " << firingOrigin;
return false;
}
if (firingOrigin.isNull())
{
if (reasonOut)
*reasonOut = QStringLiteral("originatorOrigin isNull");
TRACE_LOG(m_logger) << LOGFUNCTION << " END, originatorOrigin isNull, " << firingOrigin;
return false;
}
TRACE_LOG(m_logger) << LOGFUNCTION << " END, originatorOrigin=" << firingOrigin;
return true;
}
LtsUtils::QPoint3D ObjectExplosionCluster::getFiringCannonGeoPosition(int explosionIndex) const
{
Core::GeoPosition geoPos = m_temporaryData.getFiringCannonGeoPosition(explosionIndex);
// in case of missing coordinates for single cannons (or ModuleTest):
if (std::isnan(geoPos.lon()) || std::isnan(geoPos.lat()) || std::isnan(geoPos.z()))
return m_data.firingCenterPosition;
return LtsUtils::QPoint3D(geoPos.lon(), geoPos.lat(), geoPos.z());
}
LtsUtils::QPoint3D ObjectExplosionCluster::getFiringCannonUtmPosition(int explosionIndex, int zoneToUse) const
{
const LtsUtils::QPoint3D &geoPoint3D = ObjectExplosionCluster::getFiringCannonGeoPosition(explosionIndex);
const LtsCoordTrans::UtmCoordinate &temp = LtsCoordTrans::UtmCoordinate::fromGeographic(geoPoint3D.toPointF(), zoneToUse);
return LtsUtils::QPoint3D(temp.x, temp.y, geoPoint3D.z());
}
std::vector<Core::GeoPosition> ObjectExplosionCluster::generateGunToTargetForm(QString *reasonOut)
{
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " START generateGunToTargetForm"
<< ", partyId: " << m_data.partyId << ", participantId: " << m_data.participantId << "---";
// origin has to be setup (via setupParticipantOrigin)
QString reason;
if (isVulcano())
{
TrajectoryGeneratorVulcano::Options opts =
// TrajectoryGeneratorVulcano::OptRasterApoTap |
TrajectoryGeneratorVulcano::OptIncludeIdealHit
// | TrajectoryGeneratorVulcano::OptRasterTapHit
;
generateTrajectoryVulcanoSpecific(0, opts, &reason); // explosionNumber = 0 -> explosionIndex = -1, means to center of area
}
else
{
generateTrajectory(0, false, &reason); // explosionNumber = 0 -> explosionIndex = -1, means to center of area
}
if (!reason.isEmpty())
{
ERROR_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " reason: " << reason;
if (reasonOut)
*reasonOut = reason;
return {};
}
// explosionNumber = 0 -> explosionIndex = -1, means to center of area
const std::vector<Core::GeoPosition> &trajOut = m_trajectoryCont[-1].trajectoryGeometry;
TRACE_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " END, GunToTarget.size = " << trajOut.size();
return trajOut;
}
void ObjectExplosionCluster::publishTrajectory(int explosionIndex)
{
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " START publishTrajectory" << ", explosionIndex=" << explosionIndex;
if (m_mainHandler->dds()->ppmDtc()->saaConnectedState(m_data.partyId) == ParticipantManagement::ConnectState::Connected)
{
DEBUG_LOG(m_logger) << "publishTrajectory isSaaConnected => keine Trajectory verschicken!";
return;
}
if (!m_trajectoryCont.contains(explosionIndex))
{
ERROR_LOG(m_logger) << "unknown explosionIndex "
<< ", m_data.id = " << m_data.id << ", explosionIndex = " << explosionIndex;
return;
}
// enable access to TracjectoryData and add time-awarenes
TracjectoryData &tdRef = m_trajectoryCont[explosionIndex];
TrajectoryTimeAware &trajectoryTimeAwareRef = tdRef.trajectoryTimeAware;
trajectoryTimeAwareRef.id(1000 * m_data.id + 100 + explosionIndex);
trajectoryTimeAwareRef.sampleTime(partitionTimeMSec());
// [E01562-259] use originatorId, originatorTypeId (instead of aesItemId, aesTypeId)
// trajectoryTimeAwareRef.aesItemId(m_data.id);
// trajectoryTimeAwareRef.aesTypeId(AesType::AtExplosionClusterSingleTrajectory);
trajectoryTimeAwareRef.index(explosionIndex);
if (isVulcano())
{
// Time:
trajectoryTimeAwareRef.trajectoryStartTime(m_data.effectStart.toMSecsSinceEpoch() - m_temporaryData.calculatedFlightDurationMsec);
#ifdef USE_TRAJECTORY_VIA_HANDLER
publishTrajectoryViaHandler(trajectoryTimeAwareRef);
#else
bool bPublished = m_mainHandler->dds()->dts()->publish(trajectoryTimeAwareRef);
if (!bPublished)
ERROR_LOG(m_logger) << LOGFUNCTION << " ERROR, publish failed" << m_data.id << " explosionIndex=" << explosionIndex
<< ", trajectoryStartTime = " << trajectoryTimeAwareRef.trajectoryStartTime()
<< ", geometry().size() = " << trajectoryTimeAwareRef.geometry().size();
#endif // USE_TRAJECTORY_VIA_HANDLER
}
else
{
// Time:
// use sample time since FiringTimer is initiates trajectory calculation
trajectoryTimeAwareRef.trajectoryStartTime(trajectoryTimeAwareRef.sampleTime());
const std::vector<Core::GeoPosition> &trajectoryGeometry = tdRef.trajectoryGeometry;
Core::GeoPosition first;
if (!trajectoryGeometry.empty())
first = trajectoryGeometry.front();
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " trajectoryGeometry=" << trajectoryGeometry.size() << ", first = " << first;
std::vector<Core::GeoPositionRelativeTime> &geometryRef = trajectoryTimeAwareRef.geometry();
geometryRef.clear();
geometryRef.reserve(trajectoryGeometry.size());
int idx = 0;
const float flightDurationMSecSeg = static_cast<float>(tdRef.flightDurationMSec) / (trajectoryGeometry.size() - 1); // enforce float calculation
#define REDUCED_DISTRIBUTION // [GUEZE-2462] Darstellung Flugparabel Steilfeuer
#ifdef REDUCED_DISTRIBUTION
const int trajSize = trajectoryGeometry.size();
for (const Core::GeoPosition &pos3D : qAsConst(trajectoryGeometry))
{
// if (!m_isAirSupportSource)
{
// High resolution at beginning to enable initial visualisation of trajectory at map display
if ((trajSize > 20) && (idx > 1))
{
// !m_isAirSupportSource:
// In der erste Haelfte der Kurve (Steigphase) nur jedes 3 item nutzen...
if ((!m_isAirSupportSource) && (idx < (trajSize / 2.0)) && (idx % 3)) // modulo 3, also nur jeden dritten nutzen
{
++idx;
continue;
}
// .. ansonsten (in der zweiten Haelfte / Fallphase) nur jedes 2 item nutzen... aber die letzten 10 direkt:
else if (idx < (trajSize - 10) && (idx % 2)) // modulo 2, also nur jeden zweiten nutzen
{
++idx;
continue;
}
} // if ((trajSize > 20) && (idx>1))
} // if (!m_isAirSupportSource)
geometryRef.emplace_back(Core::GeoPositionRelativeTime(pos3D.lon(), pos3D.lat(), pos3D.z(), idx * flightDurationMSecSeg));
++idx;
} // for
#else
for (const Core::GeoPosition &pos3D : qAsConst(trajectoryGeometry))
{
geometryRef.emplace_back(Core::GeoPositionRelativeTime(pos3D.lon(), pos3D.lat(), pos3D.z(), idx * flightDurationMSecSeg));
++idx;
} // for
#endif
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " explosionIndex=" << explosionIndex << " has flightDurationMSecSeg=" << flightDurationMSecSeg
<< ", startTime = " << trajectoryTimeAwareRef.trajectoryStartTime() << ", geometry().size() = " << trajectoryTimeAwareRef.geometry().size();
#ifdef USE_TRAJECTORY_VIA_HANDLER
publishTrajectoryViaHandler(trajectoryTimeAwareRef);
#else
bool bPublished = m_mainHandler->dds()->dts()->publish(trajectoryTimeAwareRef);
if (!bPublished)
ERROR_LOG(m_logger) << LOGFUNCTION << " ERROR, publish failed" << m_data.id << " explosionIndex=" << explosionIndex
<< " has flightDurationMSecSeg=" << flightDurationMSecSeg << ", startTime = " << trajectoryTimeAwareRef.trajectoryStartTime()
<< ", geometry().size() = " << trajectoryTimeAwareRef.geometry().size();
#endif // USE_TRAJECTORY_VIA_HANDLER
}
m_publisedTrajectoriesForDebug[explosionIndex] = QString(QStringLiteral("trajectoryPublished m_data.id=%1 - explosionIndex=%2 - trajectoryStarttime=%3 - size=%4"))
.arg(m_data.id)
.arg(explosionIndex)
.arg(trajectoryTimeAwareRef.trajectoryStartTime())
.arg(trajectoryTimeAwareRef.geometry().size());
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " add to m_publisedTrajectoriesForDebug " << m_publisedTrajectoriesForDebug[explosionIndex];
DEBUG_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " add to m_publisedTrajectoriesForDebug.size = " << m_publisedTrajectoriesForDebug.size();
TRACE_LOG(m_logger) << LOGFUNCTION << " " << m_data.id << " XXXX 4 trajectoryTimeAware.geometry().size() = " << trajectoryTimeAwareRef.geometry().size()
// << ", bPublished=" << bPublished
;
}
void ObjectExplosionCluster::publishTrajectoryViaHandler(const TrajectoryTimeAware &trajectoryTimeAwareRef)
{
const int explosionIndex = trajectoryTimeAwareRef.index();
TrajectoryData trajData;
trajData.id = m_trajectoryHandlerExplosionIndexToTopicId.value(explosionIndex, -1); // default value of -1 mean, create
// [E01562-259] use originatorId, originatorTypeId (instead of aesItemId, aesTypeId)
// trajData.aesItemId = m_data.id;
// trajData.aesTypeId = AesType::AtExplosionClusterSingleTrajectory;
trajData.index = explosionIndex;
trajData.originatorId = m_data.id; // m_data.id == aesItemId
trajData.originatorTypeId = ProjectDataManagement::StateChangeOriginator::AreaEffectSimulation;
trajData.startTime = trajectoryTimeAwareRef.trajectoryStartTime();
trajData.geometry = trajectoryTimeAwareRef.geometry();
const int id = m_mainHandler->trajectoryHandler()->createUpdate(trajData);
DEBUG_LOG(m_logger) << LOGFUNCTION << "trajectoryHandler::createUpdate with id= " << id;
if (id < 0)
{
ERROR_LOG(m_logger) << LOGFUNCTION << " ERROR, publish failed" << m_data.id << " explosionIndex=" << explosionIndex
<< ", startTime = " << trajectoryTimeAwareRef.trajectoryStartTime() << ", geometry().size() = " << trajectoryTimeAwareRef.geometry().size();
}
// update internal lookup table:
m_trajectoryHandlerExplosionIndexToTopicId[explosionIndex] = id;
}
void ObjectExplosionCluster::dump(const char *file, int lineNo) const
{
// const int currentExplosionNumberVal = currentExplosionNumber();
DEBUG_LOG(m_logger) << "START ******* DUMP: id = " << m_data.id << ", name = '" << m_data.name << "' **************";
DEBUG_LOG(m_logger) << "START ******* DUMP: id = " << m_data.id << ", caller= " << file << ":" << lineNo;
DEBUG_LOG(m_logger) << "START ******* DUMP: id = " << m_data.id << ", this= " << this;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: ** isValid / annotationString ** = '" << m_temporaryData.annotationString << "'";
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: isCentral = " << m_data.isCentral;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: effectStateId = " << m_data.effectStateId;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: effectDuration = " << m_data.effectDuration;
const qint64 nowMsec = partitionTimeMSec();
const qint64 activationMsec = activationTime().toMSecsSinceEpoch();
const qint64 preStartMsec = activationMsec - m_temporaryData.estimatedMaxFlightDurationMSec;
const bool bReached = nowMsec >= preStartMsec;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: nowMsec = " << nowMsec << " - " << QDateTime::fromMSecsSinceEpoch(nowMsec).toString();
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: activationMsec = " << activationMsec << " - " << QDateTime::fromMSecsSinceEpoch(activationMsec).toString();
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: preStartMsec = " << preStartMsec << " - " << QDateTime::fromMSecsSinceEpoch(preStartMsec).toString();
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: leftMsec = " << preStartMsec - nowMsec;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: bReached = " << bReached;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: originalEffectDuration = " << m_data.originalEffectDuration;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: originalEffectStart (Msec) = " << m_data.originalEffectStart.toMSecsSinceEpoch() << " - "
<< m_data.originalEffectStart.toString();
// DEBUG_LOG(m_logger) << m_data.id << ", DUMP: impactDeltaMSec() = " << impactDeltaMSec();
// DEBUG_LOG(m_logger) << m_data.id << ", DUMP: currentExplosionNumber() = " << currentExplosionNumberVal;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: m_lastSentTriggeredExplosionNumber = " << m_lastSentTriggeredExplosionNumber;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: m_publishDataTimer->isActive = " << m_publishDataTimer->isActive();
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: m_singleExplosionTriggerTimer->isActive = " << m_singleExplosionTriggerTimer->isActive();
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: m_preStartTimer->isActive = " << m_preStartTimer->isActive();
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: impactCount = " << m_data.impactCount;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: chargeTypeId = " << m_data.chargeTypeId;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: impactRadius = "
<< m_mainHandler->dds()->pdmDtc()->impactRadius(m_data.chargeTypeId, m_data.igniterTypeId, m_data.igniterFunctionId);
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: impactEdgeLength = "
<< m_mainHandler->dds()->pdmDtc()->impactEdgeLength(m_data.chargeTypeId, m_data.igniterTypeId, m_data.igniterFunctionId);
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: firingParticipantId = " << m_data.participantId;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: m_data.firingGeoPosition = " << m_data.firingCenterPosition;
const LtsCoordTrans::UtmCoordinate &firingOriginUtm = LtsCoordTrans::UtmCoordinate::fromGeographic(m_data.firingCenterPosition.toPointF());
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: m_data.firingOriginUtm = " << firingOriginUtm;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: m_temporaryData.m_firingUnitOriginUtm = " << m_temporaryData.m_firingUnitOriginUtm;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: m_temporaryData.m_firingUnitOriginUtmPoint3D = " << m_temporaryData.m_firingUnitOriginUtmPoint3D;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: m_temporaryData.mhPoints.size() = " << m_temporaryData.mhPoints.size();
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: m_temporaryData.mhpWidth X = " << m_temporaryData.mhpWidth;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: m_temporaryData.mhpLength Y = " << m_temporaryData.mhpLength;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: m_temporaryData.mhpRotation = " << m_temporaryData.mhpRotation;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: estimatedMaxFlightDurationMSec = " << m_temporaryData.estimatedMaxFlightDurationMSec;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: estimatedMaxFlightDurationSec = " << m_temporaryData.estimatedMaxFlightDurationMSec / 1000.0;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: m_data.peakHeight (relToFiring) = " << m_data.peakHeight;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: m_data.flightDuration = " << m_data.flightDuration;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: calculatedFiringAngle = " << m_temporaryData.calculatedFiringAngle;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: calculatedFiringSpeed = " << m_temporaryData.calculatedFiringSpeed;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: calculatedFlightDurationMsec = " << m_temporaryData.calculatedFlightDurationMsec;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: calculatedPeakHeightAbs = " << m_temporaryData.calculatedPeakHeightAbs;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: m_data.mhpRotationRequest = " << m_data.mhpRotationRequest;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: calculatedMhpRotationNorthDeg = " << m_temporaryData.calculatedMhpRotationNorthDeg;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: launchVelocity [m/s] = " << m_data.launchVelocity;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: launchAngleDeg = " << m_data.launchAngleDeg;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: dropAngle = " << m_data.dropAngle;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: tapTime/timepoint [msec] = " << m_data.tapTimepoint;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: lcAttack (lcPrf) = " << m_data.lcPrf;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: lcTermination = " << m_data.lcTermination;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: cloudBase = " << m_data.cloudBase;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: impactPosition (X/Y) = " << m_data.impactPosition.x() << "/" << m_data.impactPosition.y();
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: isObjectModifiable = " << m_temporaryData.isObjectModifiable;
if (m_trajectoryCont.contains(0))
{
const TracjectoryData &tdRef = m_trajectoryCont[0];
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: trajectoryCont[0].flightDuration= " << tdRef.flightDurationMSec;
}
QString trajectoryContKeys;
const QList<int> &keysCont = m_trajectoryCont.keys();
for (auto key : keysCont)
trajectoryContKeys.append(QString(QStringLiteral("%1;")).arg(key));
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: m_trajectoryCont.keys()= " << trajectoryContKeys;
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: m_publisedTrajectoriesForDebug.size = " << m_publisedTrajectoriesForDebug.size();
for (const auto &item : qAsConst(m_publisedTrajectoriesForDebug))
DEBUG_LOG(m_logger) << m_data.id << ", DUMP: m_publisedTrajectoriesForDebug = " << item;
DEBUG_LOG(m_logger) << "END ******* DUMP: id = " << m_data.id << ", name = '" << m_data.name << "' **************";
}
// qint64 ObjectExplosionCluster::impactDeltaMSec() const
//{
// const qint64 impactCount = m_data.impactCount; // double for calculation below
// if (impactCount <= 0)
// return 24 * 60 * 60 * 1000; // 1day - more or less invalid
// if (m_data.originalEffectDuration > 0)
// return m_data.originalEffectDuration / impactCount; // msecs between impacts
// else
// return 500; // In case of invalid (0) effect duration time, return 500 msecs.
// }
// int ObjectExplosionCluster::currentExplosionNumber() const
//{
// // Context ExplosionCluster Point geometry, single impact:
// // Sometimes trySwitchToActivated is executed wit a delay. (reason is unknown, most likely timing)
// // Then more than a half of the duration is already over!
// // Under that conditions 'lrint(completedEffectDuration / delta_t);' return 1, but 0 was assumed
// // lrint(0.1) -> 0
// // lrint(0.4) -> 0
// // lrint(0.5) -> 0
// // lrint(0.501) -> 1
// // See: 2024-06-12 09:22:34.558 DEBUG AES::ObjectExplosionCluster |#| Current explosion number is 1, ic: 1, dt: 1000, cd: 556.00, exd: 0.00, curD: 556.00, odur:
// 1000, edur: 1000, hasEffectStart: 1 (/AreaEffectSimulation/object_explosion_cluster.cpp:2505)
// // So the caller assumes that there is no exposion left! This wrong!
// if ((m_data.impactCount == 1) &&
// (m_lastSentTriggeredExplosionNumber <= 0) )
// {
// const int ret = 1; // 1 for proper bit setting
// DEBUG_LOG(m_logger) << "Current explosion number is " << ret;
// return ret;
// }
// const qint64 delta_t = impactDeltaMSec();
// const bool hasEffectStart = m_data.effectStart.isValid();
// const double curDuration = hasEffectStart ? partitionTimeMSec() - m_data.effectStart.toMSecsSinceEpoch() : 0; // exhaused between last start and now
// if (curDuration < 0) // effectStart not reached;
// return 0;
// const double exhausedDuration = m_data.originalEffectDuration - m_data.effectDuration; // exhaused till last start
// const double completedEffectDuration = exhausedDuration + curDuration;
// const int ret = lrint(completedEffectDuration / delta_t);
// DEBUG_LOG(m_logger) << "Current explosion number is " << ret
// << ", ic: " << m_data.impactCount
// << ", dt: " << delta_t
// << ", cd: " << QString::number(completedEffectDuration,'f', 2)
// << ", exd: " << QString::number(exhausedDuration,'f', 2)
// << ", curD: " << QString::number(curDuration,'f', 2)
// << ", odur: " << m_data.originalEffectDuration
// << ", edur: " << m_data.effectDuration
// << ", hasEffectStart: " << hasEffectStart
// ;
// return ret + 1; // start at 1 for proper bit setting
//}
DetonationLocationRequest ObjectExplosionCluster::detonationLocationRequest(int explosionIndex) const
{
DetonationLocationRequest req;
req.id(m_data.id); // m_data.id == AesItemId
req.index(explosionIndex);
req.chargeTypeId(m_data.chargeTypeId);
req.igniterTypeId(m_data.igniterTypeId);
req.igniterFunctionId(m_data.igniterFunctionId);
req.trajectory(m_trajectoryCont[explosionIndex].trajectoryGeometry);
return req;
}
void ObjectExplosionCluster::setAesProperty(QJsonObject property, bool pubish)
{
QJsonObject propertiesObject = QJsonDocument::fromJson(m_data.properties.toUtf8()).object();
// same as QJsonObject.merge
for (auto it = property.begin(); it != property.end(); ++it)
{
propertiesObject.insert(it.key(), it.value());
}
QJsonDocument doc(propertiesObject);
QByteArray propertiesArr = QJsonDocument(doc).toJson(QJsonDocument::Compact);
m_data.properties = QString::fromUtf8(propertiesArr);
if (pubish)
onPublishData();
}
QPolygonF ObjectExplosionCluster::generateForm() { return Polygons::explosionClusterArea(m_data); }
} // Namespace AreaEffectSimulation
Reference in new issue View Git Blame Copy Permalink