.

utils/orbBlock.cpp

 #include "orbBlock.h"
-#include <utility>
 #include "TextFunctions.h"
 
 OrbBlock::OrbBlock()
@@ -15,11 +14,10 @@ OrbBlock::OrbBlock(
 )
     :
     m_orbit(orbit),
-    m_beg(beg),
-    m_end(end),
-    m_mind(-1),
     m_ip(nullptr)
 {
+    m_data = orb_block_data(orbit.GetId(), orbit.GetDate(), beg, end);
+
 #ifdef _DEBUG
     m_beg_s = DateToStr(beg);
     m_end_s = DateToStr(end);
@@ -31,16 +29,14 @@ OrbBlock::OrbBlock(
     const TimeJD& beg,
     const TimeJD& end,
     const double mind,
-    std::string next_orbitid
+    const std::string& next_orbitid
 )
     :
     m_orbit(orbit),
-    m_beg(beg),
-    m_end(end),
-    m_mind(mind),
-    m_next_orbitid(std::move(next_orbitid)),
     m_ip(nullptr)
 {
+    m_data = orb_block_data(orbit.GetId(), orbit.GetDate(), beg, end, mind, next_orbitid);
+
 #ifdef _DEBUG
     m_beg_s = DateToStr(beg);
     m_end_s = DateToStr(end);
@@ -59,33 +55,6 @@ void OrbBlock::interpolate(const TimeJD& beg, const TimeJD& end)
 
 void OrbBlock::load(const jsonval& parent)
 {
-    std::string orbitid;
-    loadjson(parent, "id", orbitid);
-    loadjson(parent, "beg", m_beg);
-    loadjson(parent, "end", m_end);
-    loadjson(parent, "mind_km", m_mind, false);
-
-    std::string vecs;
-    loadjson(parent, "vecs", vecs, false);
-
-    static std::vector<std::string> arr = splitstr(vecs, ",");
-
-    std::vector<IRes> vres;
-    for (size_t i = 0; i < arr.size(); i += 8) {
-        int days;
-        Converter::ToNumber(arr[i], days);
-
-        double fraction;
-        Converter::ToNumber(arr[i + 1], fraction);
-
-        double x, y, z, vx, vy, vz;
-        Converter::ToNumber(arr[i + 2], x);
-        Converter::ToNumber(arr[i + 3], y);
-        Converter::ToNumber(arr[i + 4], z);
-        Converter::ToNumber(arr[i + 5], vx);
-        Converter::ToNumber(arr[i + 6], vy);
-        Converter::ToNumber(arr[i + 7], vz);
-
-        vres.emplace_back(Vect6(x, y, z, vx, vy, vz), TimeJD(days, fraction), 0, orbitid);
-    }
+    m_data.load(parent);
 }
+

utils/orbBlock.h

@@ -4,28 +4,27 @@
 #include "StateVector.h"
 #include "interpolate.h"
 #include "json_functions.h"
+#include "orb_block_data.h"
 
 class OrbBlock {
 public:
     OrbBlock();
     OrbBlock(const SInitOrbit& orbit, const TimeJD& beg, const TimeJD& end);
-    OrbBlock(const SInitOrbit& orbit, const TimeJD& beg, const TimeJD& end, double mind, std::string next_orbitid);
+    OrbBlock(const SInitOrbit& orbit, const TimeJD& beg, const TimeJD& end, double mind, const std::string& next_orbitid);
     ~OrbBlock();
 
-    TimeJD get_beg() const { return m_beg; }
-    TimeJD get_end() const { return m_end; }
+    TimeJD get_beg() const { return get_data().get_beg(); }
+    TimeJD get_end() const { return get_data().get_end(); }
     const SInitOrbit& get_orbit() const { return m_orbit; }
-    double get_min_distance() const { return m_mind; }
-    std::string get_next_orbitid() const { return m_next_orbitid; }
+    double get_min_distance() const { return get_data().get_min_distance(); }
+    std::string get_next_orbitid() const { return get_data().get_next_orbitid(); }
     void interpolate(const TimeJD& beg, const TimeJD& end);
     const XInterpolator* get_interpolator() const { return m_ip; }
     void load(const jsonval& parent);
+    const orb_block_data& get_data() const { return m_data; }
 private:
     SInitOrbit m_orbit;
-    TimeJD m_beg;
-    TimeJD m_end;
-    double m_mind;
-    std::string m_next_orbitid;
+    orb_block_data m_data;
     XInterpolator* m_ip;
 
 #ifdef _DEBUG

utils/orbBlocks.cpp

@@ -3,8 +3,7 @@
 #include "xalgorithm.h"
 #include "orb_date.h"
 
-OrbBlocksStore::OrbBlocksStore()
-= default;
+OrbBlocksStore::OrbBlocksStore() = default;
 
 void OrbBlocksStore::init(
     const SInitOrbits& orbits,
@@ -267,6 +266,15 @@ const SInitOrbit& OrbBlocksStore::get_orbit(const TimeJD& date) const
     throw Exp() << "no orbit found";
 }
 
+std::vector<orb_block_data> OrbBlocksStore::get_orb_data() const
+{
+    std::vector<orb_block_data> result;
+    for(const auto& el: m_blocks) {
+        result.emplace_back(el.get_data());
+    }
+    return result;
+}
+
 SInitOrbits OrbBlocksStore::calc_orbits(std::vector<TimeJD> dates, bool variates) const
 {
     std::sort(dates.begin(), dates.end(), [](const TimeJD& a, const TimeJD& b) {

utils/orbBlocks.h

@@ -18,6 +18,7 @@ public:
     Vect6 get_pos(const TimeJD& date) const;
     const SInitOrbit& get_orbit(const TimeJD& date) const;
     const OrbBlocks& get_blocks() const { return m_blocks; }
+    std::vector<orb_block_data> get_orb_data() const;
     OrbBlocks& get_blocks() { return m_blocks; }
     const TimeJD& get_beg_before_filter() const { return m_beg_before_filter; }
     const TimeJD& get_end_before_filter() const { return m_end_before_filter; }

utils/orb_block_data.cpp

+#include "orb_block_data.h"
+#include "json_functions_bno.h"
+
+orb_block_data::orb_block_data(
+    std::string orbitid,
+    const TimeJD& date,
+    const TimeJD& beg,
+    const TimeJD& end
+)
+    :
+    m_orbitid(std::move(orbitid)),
+    m_date(date),
+    m_beg(beg),
+    m_end(end),
+    m_mind(-1)
+{
+}
+
+orb_block_data::orb_block_data(
+    std::string orbitid,
+    const TimeJD& date,
+    const TimeJD& beg,
+    const TimeJD& end,
+    const double mind,
+    std::string next_orbitid
+)
+    :
+    m_orbitid(std::move(orbitid)),
+    m_next_orbitid(std::move(next_orbitid)),
+    m_date(date),
+    m_beg(beg),
+    m_end(end),
+    m_mind(mind)
+{
+}
+
+void orb_block_data::load(const jsonval& parent)
+{
+    loadjson(parent, "id", m_orbitid);
+    loadjson(parent, "date", m_date);
+    loadjson(parent, "beg", m_beg);
+    loadjson(parent, "end", m_end);
+    loadjson(parent, "mind_km", m_mind, false);
+}

utils/orb_block_data.h

+#pragma once
+
+#include "TM.h"
+#include "json_functions.h"
+
+class orb_block_data {
+public:
+    orb_block_data() = default;
+    orb_block_data(
+        std::string orbitid, 
+        const TimeJD& date, 
+        const TimeJD& beg, 
+        const TimeJD& end);
+    orb_block_data(
+        std::string orbitid, 
+        const TimeJD& date, 
+        const TimeJD& beg, 
+        const TimeJD& end, 
+        double mind, 
+        std::string next_orbitid);
+    void load(const jsonval& parent);
+    TimeJD get_date() const { return m_date; }
+    TimeJD get_beg() const { return m_beg; }
+    TimeJD get_end() const { return m_end; }
+    const std::string& get_orbitid() const { return m_orbitid; }
+    const std::string& get_next_orbitid() const { return m_next_orbitid; }
+    double get_min_distance() const { return m_mind; }
+private:
+    std::string m_orbitid;
+    std::string m_next_orbitid;
+    TimeJD m_date;
+    TimeJD m_beg;
+    TimeJD m_end;
+    double m_mind;
+};
+

utils/orb_date.cpp

@@ -98,8 +98,7 @@ void calc_orbit_on_dates(const SInitOrbit& orbit, std::vector<TimeJD> dates, boo
         return;
     }
 
-    std::sort(dates.begin(), dates.end(), [](const TimeJD& a, const TimeJD& b)
-    {
+    std::sort(dates.begin(), dates.end(), [](const TimeJD& a, const TimeJD& b) {
         return a < b;
     });
 
@@ -130,13 +129,27 @@ std::vector<SInitOrbit> calc_orbits_on_dates(const SInitOrbit& orbit, const Time
     return calc_orbits_on_dates(orbit, generate_dates(beg, end, step_sec), variates);
 }
 
+double calc_age(const SInitOrbit& orbit, const TimeJD& date)
+{
+    const TimeJD orbit_beg = ShiftDate(orbit.GetDate(), -orbit.GetInterval() * 86400);
+    const TimeJD& orbit_end = orbit.GetDate();
+        
+    double age_days = 0;
+    if (date < orbit_beg) {
+        age_days = DaysInterval(orbit_beg, date);
+    }
+    else if (date > orbit_end) {
+        age_days = DaysInterval(date, orbit_end);
+    }
+    return age_days;
+}
+
 std::vector<IRes> calc_positions_on_dates(const SInitOrbit& orbit, const std::vector<TimeJD>& dates)
 {
     std::vector<IRes> result;
     calc_orbit_on_dates(orbit, dates, false, result);
 
-    std::sort(result.begin(), result.end(), [](const IRes& a, const IRes& b)
-    {
+    std::sort(result.begin(), result.end(), [](const IRes& a, const IRes& b) {
         return a.get_date() < b.get_date();
     });
 
@@ -148,8 +161,7 @@ std::vector<SInitOrbit> calc_orbits_on_dates(const SInitOrbit& orbit, const std:
     std::vector<SInitOrbit> result;
     calc_orbit_on_dates(orbit, dates, variates, result);
 
-    std::sort(result.begin(), result.end(), [](const SInitOrbit& a, const SInitOrbit& b)
-    {
+    std::sort(result.begin(), result.end(), [](const SInitOrbit& a, const SInitOrbit& b) {
         return a.GetDate() < b.GetDate();
     });
 

utils/orb_date.h

@@ -10,3 +10,4 @@ std::vector<IRes> calc_positions_on_dates(const SInitOrbit& orbit, const TimeJD&
 std::vector<IRes> calc_positions_on_dates(const SInitOrbit& orbit, const std::vector<TimeJD>& dates);
 std::vector<SInitOrbit> calc_orbits_on_dates(const SInitOrbit& orbit, const std::vector<TimeJD>& dates, bool variates);
 std::vector<SInitOrbit> calc_orbits_on_dates(const SInitOrbit& orbit, const TimeJD& beg, const TimeJD& end, double step_sec, bool variates);
+double calc_age(const SInitOrbit& orbit, const TimeJD& date);