Refactor/new simcore lib

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.26...4.2)
-project(im_sample_algorithm VERSION 5.3.2 LANGUAGES CXX)
+project(im_sample_algorithm VERSION 6.0.0 LANGUAGES CXX)
 
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
@@ -34,7 +34,7 @@ message(STATUS "${PROJECT_NAME}: Generating build version ${msg_VERSION}")
 # Begin project dependencies ------------------------------------------------------
 set(
     IM_SAMPLE_ALGORITHM_AIRCRAFT_SIMULATION_CORE_TAG
-    "1.0.0"
+    "2.0.0"
     CACHE STRING "aircraft_simulation_core tag used for im_sample_algorithm builds"
 )
 set(IM_SAMPLE_ALGORITHM_FSLOADER_TAG "1.1.0" CACHE STRING "fsloader tag used for im_sample_algorithm builds")

IntervalManagement/AchievePointCalcs.cpp

@@ -30,7 +30,7 @@
 #include "utility/CustomUnits.h"
 
 using namespace std;
-using namespace aaesim::open_source;
+using namespace mitre::oss::simcore;
 using namespace interval_management::open_source;
 
 #define SQR(x)           \
@@ -115,13 +115,14 @@ void AchievePointCalcs::ComputeDefaultTRP(const AchievePointCalcs &ownship_calcs
                                           Waypoint &traffic_reference_point, Units::Length &waypoint_x,
                                           Units::Length &waypoint_y, size_t &waypoint_index_in_target_intent) {
    // Get ABP index from ownship
-   int ix0 = ownship_intent.GetWaypointIndexByName(ownship_calcs.GetWaypointName());
-   if (ix0 < 0) {
+   const auto achieve_by_index = ownship_intent.GetWaypointIndexByName(ownship_calcs.GetWaypointName());
+   if (!achieve_by_index) {
       string emsg = "Illegal ownship achieve-by point " + ownship_calcs.GetWaypointName() +
                     " encountered while computing achieve point calculations positions";
       LOG4CPLUS_FATAL(AchievePointCalcs::m_logger, emsg);
       throw logic_error(emsg);
    }
+   int ix0 = static_cast<int>(*achieve_by_index);
 
    int ix1 = ix0 + 1;
    if (ix1 >= ownship_intent.GetNumberOfWaypoints()) {
@@ -376,13 +377,14 @@ void AchievePointCalcs::ComputeDefaultTRP(const AchievePointCalcs &ownship_calcs
       try {
          distance_calculator.CalculateAlongPathDistanceFromPosition(x, y, distance_to_end);
       } catch (std::logic_error &e) {
-         LOG4CPLUS_ERROR(m_logger, target_intent.GetWaypointName(i)
+         LOG4CPLUS_ERROR(m_logger, target_intent.GetWaypointName(i).value_or("<unknown>")
                                          << " at (" << x << "," << y << ") is not on horizontal path.");
          continue;
       }
       Units::MetersLength distance_to_trp = distance_to_end - distance_trp_to_end;
       LOG4CPLUS_TRACE(m_logger,
-                      "Distance from " << target_intent.GetWaypointName(i) << " to TRP is " << distance_to_trp);
+                      "Distance from " << target_intent.GetWaypointName(i).value_or("<unknown>")
+                                       << " to TRP is " << distance_to_trp);
       if (distance_to_trp <= Units::MetersLength(100)) {
          waypoint_index_in_target_intent = i;
          break;
@@ -394,18 +396,18 @@ void AchievePointCalcs::ComputeDefaultTRP(const AchievePointCalcs &ownship_calcs
 
 void AchievePointCalcs::ComputePositions(const AircraftIntent &intent) {
    if (this->HasWaypoint()) {
-      int ix = intent.GetWaypointIndexByName(m_waypoint_name);
+      const auto waypoint_index = intent.GetWaypointIndexByName(m_waypoint_name);
 
-      if (ix > -1) {
-         m_waypoint_x = Units::MetersLength(intent.GetRouteData().m_x[ix]);
-         m_waypoint_y = Units::MetersLength(intent.GetRouteData().m_y[ix]);
+      if (waypoint_index) {
+         m_waypoint_x = Units::MetersLength(intent.GetRouteData().m_x[*waypoint_index]);
+         m_waypoint_y = Units::MetersLength(intent.GetRouteData().m_y[*waypoint_index]);
       } else {
          string emsg = "Illegal achieve point " + m_waypoint_name +
                        " encountered while computing achieve point calculations positions";
          LOG4CPLUS_FATAL(AchievePointCalcs::m_logger, emsg);
          throw logic_error(emsg);
       }
-      LOG4CPLUS_DEBUG(m_logger, "Waypoint[" << ix << "] = " << m_waypoint_name << "(" << m_waypoint_x << ","
+      LOG4CPLUS_DEBUG(m_logger, "Waypoint[" << *waypoint_index << "] = " << m_waypoint_name << "(" << m_waypoint_x << ","
                                             << m_waypoint_y << ")");
    }
 }

IntervalManagement/AircraftIntentLoader.cpp

@@ -25,8 +25,9 @@
 #include "imalgs/WaypointLoader.h"
 
 namespace {
-std::list<Waypoint> BuildWaypointList(const std::list<interval_management::loaders::WaypointLoader> &waypoint_loaders) {
-   std::list<Waypoint> waypoints;
+std::list<mitre::oss::simcore::Waypoint>
+BuildWaypointList(const std::list<interval_management::loaders::WaypointLoader> &waypoint_loaders) {
+   std::list<mitre::oss::simcore::Waypoint> waypoints;
    for (const auto &waypoint_loader : waypoint_loaders) {
       waypoints.push_back(waypoint_loader.BuildWaypoint());
    }
@@ -60,7 +61,11 @@ bool AircraftIntentLoader::load(DecodedStream *input) {
                       "No waypoints were found in the scenario file. Check the aircraft_intent{} input block.");
       throw std::runtime_error("Must provide waypoints.");
    } else {
-      aircraft_intent_.LoadWaypointsFromList(ascent_waypoints, cruise_waypoints, descent_waypoints);
+      aircraft_intent_ = open_source::FIMAircraftIntent::Builder()
+                              .LoadWaypoints({ascent_waypoints.begin(), ascent_waypoints.end()},
+                                             {cruise_waypoints.begin(), cruise_waypoints.end()},
+                                             {descent_waypoints.begin(), descent_waypoints.end()})
+                              .Build();
    }
 
    return is_loaded_;

IntervalManagement/AircraftState.cpp

@@ -25,6 +25,8 @@
 #include "public/CustomMath.h"
 #include "utility/CustomUnits.h"
 
+using namespace mitre::oss::simcore;
+
 log4cplus::Logger interval_management::open_source::AircraftState::m_logger =
       log4cplus::Logger::getInstance(LOG4CPLUS_TEXT("AircraftState"));
 

IntervalManagement/ClosestPointMetric.cpp

@@ -33,7 +33,7 @@ void ClosestPointMetric::update(double imx, double imy, double targx, double tar
    // imx,imy:position of IM aircraft.
    // targx,targy:position of target aircraft.
 
-   Units::Length dist = aaesim::open_source::AircraftCalculations::PtToPtDist(
+   Units::Length dist = mitre::oss::simcore::AircraftCalculations::PtToPtDist(
          Units::FeetLength(imx), Units::FeetLength(imy), Units::FeetLength(targx), Units::FeetLength(targy));
 
    if (dist < mMinDist) {

IntervalManagement/FIMAlgorithmAdapter.cpp

@@ -37,17 +37,21 @@ interval_management::open_source::FIMAlgorithmAdapter::FIMAlgorithmAdapter(std::
    : m_im_algorithm(im_algorithm), m_im_algorithm_type(algorithm_type) {}
 
 void interval_management::open_source::FIMAlgorithmAdapter::Initialize(
-      aaesim::open_source::FlightDeckApplicationInitializer &initializer_visitor) {
+      mitre::oss::simcore::FlightDeckApplicationInitializer &initializer_visitor) {
    auto ownship_intent_from_clearance = m_im_algorithm->GetClearance().GetOwnshipIntent();
    if (ownship_intent_from_clearance.has_value()) {
-      initializer_visitor.fms_prediction_parameters.fms_intent = ownship_intent_from_clearance.value();
+      initializer_visitor.fms_prediction_parameters.fms_intent =
+            std::make_shared<FIMAircraftIntent>(ownship_intent_from_clearance.value());
    }
-   m_im_algorithm->ValidateClearance(initializer_visitor.fms_prediction_parameters.fms_intent, m_im_algorithm_type);
+   m_im_algorithm->ValidateClearance(*initializer_visitor.fms_prediction_parameters.fms_intent, m_im_algorithm_type);
    initializer_visitor.fms_prediction_parameters.fms_intent =
-         AircraftIntent::CopyAndTrimAfterNamedWaypoint(initializer_visitor.fms_prediction_parameters.fms_intent,
-                                                       m_im_algorithm->GetClearance().GetPlannedTerminationPoint());
-   auto waypoints =
-         CoreUtils::ShortenLongLegs(initializer_visitor.fms_prediction_parameters.fms_intent.GetWaypointList());
+         std::make_shared<FIMAircraftIntent>(FIMAircraftIntent::Builder(
+               mitre::oss::simcore::AircraftIntentUtils::CopyAndTrimAfterNamedWaypoint(
+                     *initializer_visitor.fms_prediction_parameters.fms_intent,
+                     m_im_algorithm->GetClearance().GetPlannedTerminationPoint()))
+                                               .Build());
+   const auto &intent_waypoints = initializer_visitor.fms_prediction_parameters.fms_intent->GetWaypoints();
+   auto waypoints = CoreUtils::ShortenLongLegs(std::list<Waypoint>(intent_waypoints.begin(), intent_waypoints.end()));
    m_position_converter = std::make_unique<SingleTangentPlaneSequence>(waypoints);
    initializer_visitor.position_converter = m_position_converter;
 
@@ -64,23 +68,22 @@ void interval_management::open_source::FIMAlgorithmAdapter::Initialize(
    }
 }
 
-aaesim::open_source::Guidance interval_management::open_source::FIMAlgorithmAdapter::Update(
-      const aaesim::open_source::SimulationTime &simtime, const aaesim::open_source::Guidance &current_guidance,
-      const aaesim::open_source::DynamicsState &dynamics_state,
-      const aaesim::open_source::AircraftState &own_truth_state) {
-   aaesim::open_source::Guidance im_algorithm_guidance = current_guidance;
+mitre::oss::simcore::Guidance interval_management::open_source::FIMAlgorithmAdapter::Update(
+      const mitre::oss::simcore::SimulationTime &simtime, const mitre::oss::simcore::Guidance &current_guidance,
+      const mitre::oss::simcore::DynamicsState &dynamics_state,
+      const mitre::oss::simcore::AircraftState &own_truth_state) {
+   mitre::oss::simcore::Guidance im_algorithm_guidance = current_guidance;
    im_algorithm_guidance.SetValid(false);
-   if (current_guidance.m_active_guidance_phase != aaesim::open_source::GuidanceFlightPhase::CRUISE_DESCENT)
+   if (current_guidance.m_active_guidance_phase != mitre::oss::simcore::GuidanceFlightPhase::CRUISE_DESCENT)
       return im_algorithm_guidance;
    if (m_im_algorithm->IsImOperationComplete()) return im_algorithm_guidance;
 
    UpdateTargetHistory(simtime);
-   aaesim::open_source::AircraftState synced_target_state = m_assap->Update(
+   mitre::oss::simcore::AircraftState synced_target_state = m_assap->Update(
          own_truth_state, m_assap->GetAdsbReceiver()->GetCurrentADSBReport(GetImClearance().GetTargetId()));
 
-   if (im_algorithm_guidance.GetSelectedSpeed().GetSpeedType() == UNSPECIFIED_SPEED) {
-      im_algorithm_guidance.SetSelectedSpeed(
-            aaesim::open_source::AircraftSpeed::OfIndicatedAirspeed(Units::KnotsSpeed(60)));
+   if (im_algorithm_guidance.GetSelectedSpeedType() == UNSPECIFIED_SPEED) {
+      im_algorithm_guidance.SetSelectedSpeedType(INDICATED_AIR_SPEED);
    }
    auto ownship_im_state = ConvertAircraftState(own_truth_state);
    auto target_im_state = ConvertAircraftState(synced_target_state);
@@ -90,15 +93,15 @@ aaesim::open_source::Guidance interval_management::open_source::FIMAlgorithmAdap
 
 interval_management::open_source::AircraftState
       interval_management::open_source::FIMAlgorithmAdapter::ConvertAircraftState(
-            const aaesim::open_source::AircraftState &state) const {
+            const mitre::oss::simcore::AircraftState &state) const {
    if (state.GetTime().value() < 0 || state.GetUniqueId() == IMUtils::UNINITIALIZED_AIRCRAFT_ID)
       return IMUtils::ConvertToIntervalManagementAircraftState(state);
 
    EarthModel::LocalPositionEnu enu_position;
    m_position_converter->ConvertGeodeticToLocal(
          EarthModel::GeodeticPosition::Of(state.GetLatitude(), state.GetLongitude()), enu_position);
    auto updated_state =
-         aaesim::open_source::AircraftState::Builder(state).Position(enu_position.x, enu_position.y)->Build();
+         mitre::oss::simcore::AircraftState::Builder(state).Position(enu_position.x, enu_position.y)->Build();
    LogAircraftState(updated_state);
    return IMUtils::ConvertToIntervalManagementAircraftState(updated_state);
 }
@@ -108,8 +111,8 @@ bool interval_management::open_source::FIMAlgorithmAdapter::IsActive() const {
 }
 
 void interval_management::open_source::FIMAlgorithmAdapter::UpdateTargetHistory(
-      const aaesim::open_source::SimulationTime &simtime) {
-   std::vector<aaesim::open_source::ADSBSVReport> recent_reports =
+      const mitre::oss::simcore::SimulationTime &simtime) {
+   std::vector<mitre::oss::simcore::ADSBSVReport> recent_reports =
          m_assap->GetAdsbReceiver()->GetReportsReceivedByTime(simtime);
    if (recent_reports.empty()) {
       return;
@@ -118,8 +121,8 @@ void interval_management::open_source::FIMAlgorithmAdapter::UpdateTargetHistory(
    for (const auto &adsb_sv_report : recent_reports) {
       if (adsb_sv_report.GetId() == GetImClearance().GetTargetId()) {
          if (adsb_sv_report.GetTime() >= Units::zero()) {
-            const aaesim::open_source::AircraftState ads_b_state =
-                  aaesim::open_source::AircraftState::FromAdsbReport(adsb_sv_report);
+            const mitre::oss::simcore::AircraftState ads_b_state =
+                  mitre::oss::simcore::AircraftState::FromAdsbReport(adsb_sv_report);
             interval_management::open_source::AircraftState imstate = ConvertAircraftState(ads_b_state);
             imstate.m_distance_to_go_meters = Units::MetersLength(m_im_algorithm->GetTargetDtgToLastWaypoint()).value();
             m_target_history.push_back(imstate);
@@ -128,7 +131,7 @@ void interval_management::open_source::FIMAlgorithmAdapter::UpdateTargetHistory(
    }
 }
 
-void FIMAlgorithmAdapter::LogAircraftState(const aaesim::open_source::AircraftState &state) {
+void FIMAlgorithmAdapter::LogAircraftState(const mitre::oss::simcore::AircraftState &state) {
    if (m_logger.getLogLevel() == log4cplus::TRACE_LOG_LEVEL) {
       json j;
       j["acid"] = state.GetUniqueId();

IntervalManagement/FIMAlgorithmDataWriter.cpp

@@ -134,8 +134,8 @@ void interval_management::open_source::FIMAlgorithmDataWriter::Finish() {
 }
 
 void interval_management::open_source::FIMAlgorithmDataWriter::Gather(
-      const int iteration_number, const aaesim::open_source::SimulationTime &time, const std::string &aircraft_id,
-      std::shared_ptr<const aaesim::open_source::FlightDeckApplication> application) {
+      const int iteration_number, const mitre::oss::simcore::SimulationTime &time, const std::string &aircraft_id,
+      std::shared_ptr<const mitre::oss::simcore::FlightDeckApplication> application) {
    const bool is_fim_application =
          CoreUtils::InstanceOf<interval_management::open_source::FIMAlgorithmAdapter>(application.get());
    if (!is_fim_application) {

IntervalManagement/FIMAlgorithmInitializer.cpp

@@ -52,25 +52,25 @@ void interval_management::open_source::FIMAlgorithmInitializer::Initialize(
 
 void interval_management::open_source::FIMAlgorithmInitializer::Initialize(
       interval_management::open_source::IMKinematicAchieve *kinematic_algorithm) {
-   kinematic_algorithm->Initialize(BuildOwnshipPredictionParameters(), fms_prediction_parameters.fms_intent,
+   kinematic_algorithm->Initialize(BuildOwnshipPredictionParameters(), *fms_prediction_parameters.fms_intent,
                                    fms_prediction_parameters.weather_prediction, position_converter);
 }
 
 void interval_management::open_source::FIMAlgorithmInitializer::Initialize(
       interval_management::open_source::IMTimeBasedAchieveMutableASG *test_vector_algorithm) {
-   test_vector_algorithm->Initialize(BuildOwnshipPredictionParameters(), fms_prediction_parameters.fms_intent,
+   test_vector_algorithm->Initialize(BuildOwnshipPredictionParameters(), *fms_prediction_parameters.fms_intent,
                                      fms_prediction_parameters.weather_prediction);
 }
 
 void interval_management::open_source::FIMAlgorithmInitializer::Initialize(
       interval_management::open_source::IMTimeBasedAchieve *time_achieve_algorithm) {
-   time_achieve_algorithm->Initialize(BuildOwnshipPredictionParameters(), fms_prediction_parameters.fms_intent,
+   time_achieve_algorithm->Initialize(BuildOwnshipPredictionParameters(), *fms_prediction_parameters.fms_intent,
                                       fms_prediction_parameters.weather_prediction, position_converter);
 }
 
 void interval_management::open_source::FIMAlgorithmInitializer::Initialize(
       interval_management::open_source::IMDistBasedAchieve *dist_achieve_algorithm) {
-   dist_achieve_algorithm->Initialize(BuildOwnshipPredictionParameters(), fms_prediction_parameters.fms_intent,
+   dist_achieve_algorithm->Initialize(BuildOwnshipPredictionParameters(), *fms_prediction_parameters.fms_intent,
                                       fms_prediction_parameters.weather_prediction, position_converter);
 }
 
@@ -96,21 +96,21 @@ const interval_management::open_source::FIMAlgorithmInitializer
 
 interval_management::open_source::FIMAlgorithmInitializer::Builder *
       interval_management::open_source::FIMAlgorithmInitializer::Builder::AddOwnshipPerformanceParameters(
-            const aaesim::open_source::OwnshipPerformanceParameters &performance_parameters) {
+            const mitre::oss::simcore::OwnshipPerformanceParameters &performance_parameters) {
    m_performance_parameters = performance_parameters;
    return this;
 }
 
 interval_management::open_source::FIMAlgorithmInitializer::Builder *
       interval_management::open_source::FIMAlgorithmInitializer::Builder::AddOwnshipFmsPredictionParameters(
-            const aaesim::open_source::OwnshipFmsPredictionParameters &prediction_parameters) {
+            const mitre::oss::simcore::OwnshipFmsPredictionParameters &prediction_parameters) {
    m_prediction_parameters = prediction_parameters;
    return this;
 }
 
 interval_management::open_source::FIMAlgorithmInitializer::Builder *
       interval_management::open_source::FIMAlgorithmInitializer::Builder::AddSurveillanceProcessor(
-            std::shared_ptr<const aaesim::open_source::ASSAP> processor) {
+            std::shared_ptr<const mitre::oss::simcore::ASSAP> processor) {
    m_surveillance_processor = processor;
    return this;
 }