dataContext.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2020-2025 European Southern Observatory (ESO)
//
// SPDX-License-Identifier: LGPL-3.0-only

#ifndef HLCC_TELIF_ELTPK_DATACONTEXT_HPP
#define HLCC_TELIF_ELTPK_DATACONTEXT_HPP
 
#include <mutex>
#include <memory>
 
#include <ptk/posastro.hpp>
#include <taiclock/taiClock.hpp>
#include <rad/dataContext.hpp>
#include "mal/utility/shared_vector.hpp"
#include "Ccsinsif.hpp"
#include "Ccsinsdetif.hpp"
 
#include "ambientdataclient/ambientData.hpp"
 
#include "eltpk/config.hpp"
#include "eltpk/oldbInterface.hpp"
#include "eltpk/monitoring.hpp"
 
 
 
 
namespace hlcc::eltpk {
 

struct AltAzOptional {
    std::optional<ptk::Radians> alt;
    std::optional<ptk::Radians> az;
};
 
 
// msc (ETCS-765): Idea: reuse ICD structs in the app, not just for comm.
// ----------------------------------------------------------------------------
// Spare the boilerplate-code of defining fields already defined in the ICD.
// The icd-gen could generate such (middleware-independent) class definitions.
// To try out this approach, I'm implementing such a class here manually.
class AgnosticPointingKernelPositions  {
 
private:
 double time_tai = 0;
 double time_dut1 = 0;
 double target_observed_alt = 0;
 double target_observed_az = 0;
 double north_angle = 0;
 double pupil_angle = 0;
 double elevation_direction_angle = 0;
 double parallactic_angle = 0;
 double ra_at_xy_from_guide_stars = 0;
 double dec_at_xy_from_guide_stars = 0;
 
public:
 
  double getTime_tai() const {return time_tai;};
  void setTime_tai(double x) { time_tai = x;};
 
  double getTime_dut1() const {return time_dut1;};
  void setTime_dut1(double x) { time_dut1 = x;};
 
  double getTarget_observed_alt() const {return target_observed_alt;};
  void setTarget_observed_alt(double x) {target_observed_alt = x;};
 
  double getTarget_observed_az() const {return target_observed_az;};
  void setTarget_observed_az(double x) {target_observed_az = x;};
 
  double getNorth_angle() const { return north_angle;};
  void setNorth_angle(double x) { north_angle = x; };
 
  double getPupil_angle() const { return pupil_angle;};
  void setPupil_angle(double x) { pupil_angle = x;};
 
  double getElevation_direction_angle() const { return elevation_direction_angle; };
  void setElevation_direction_angle(double x) { elevation_direction_angle = x;};
 
  double getParallactic_angle() const { return parallactic_angle; };
  void setParallactic_angle(double x) { parallactic_angle = x;};
 
  double getRa_at_xy_from_guide_stars() const { return ra_at_xy_from_guide_stars; };
  void setRa_at_xy_from_guide_stars(double x) { ra_at_xy_from_guide_stars = x;};
 
  double getDec_at_xy_from_guide_stars() const { return dec_at_xy_from_guide_stars; };
  void setDec_at_xy_from_guide_stars(double x) { dec_at_xy_from_guide_stars = x;};
}; // -----------------------------------------------------------------------
 

class DataContext : public rad::DataContext {
 public:
    DataContext(std::shared_ptr<OldbInterface> oldb_interface = nullptr);

    virtual ~DataContext();
 

    void ReloadConfig() override;

    Config& GetConfig() override;

    const Config& GetConfigConst() const;

    void UpdateDb() override;

    OldbInterface& GetOldbInterface() override;
 

    void EnablePublishing(bool enabled);

    bool IsPublishingEnabled() const;

 
    std::shared_ptr<const ::ccsinsif::PresetData> GetPresetData();


    void SetPresetArgs(std::shared_ptr<const ::ccsinsif::PresetArgs> preset_args);

    ptk::EquatorialPosition GetTargetRaDec() const;

    void SetTargetRaDec(ptk::EquatorialPosition pos);

    ptk::EquatorialPosition GetTargetRaDecCirs() const;

    void SetTargetRaDecCirs(const ptk::EquatorialPosition& pos_cirs);

    bool GetTargetRaDecValidity() const;

    void SetTargetRaDecValidity(bool is_valid);
 


    std::optional<ptk::HorizonPositionEsoTimestamped> GetTargetAltAz(
            ::taiclock::TaiClock::time_point time_tai = ::taiclock::TaiClock::time_point{}) const;

    void SetTargetAltAz(
            const ptk::HorizonPositionEsoTimestamped& alt_az, ElapsedTimeStats& stats);

    void SetTargetAltAzToCurrent(ElapsedTimeStats& stats);

    ptk::HorizonPositionEsoTimestamped MergeTargetAltAz(const AltAzOptional& alt_az,
            ElapsedTimeStats& stats, ::taiclock::TaiClock::time_point time_tai = ptk::NextTimeEvent());

    bool GetTargetAltAzValidity() const;

    void SetTargetAltAzValidity(bool is_valid);
 


    ptk::HorizonPositionEsoTimestamped GetCurrentAltAz() const;

    void SetCurrentAltAz(const ptk::HorizonPositionEsoTimestamped& alt_az);
 


    enum class EstimatedState {
        UNDEFINED,
        STANDING_STILL,
        PRESETTING,
        TRACKING,
        MOVING
    };

    void SetEstimatedState(EstimatedState state);

    EstimatedState GetEstimatedState() const;
 


    AgnosticPointingKernelPositions GetPointingKernelPositions() const;

    void SetPointingKernelPositions(const AgnosticPointingKernelPositions& x, ElapsedTimeStats& stats);
 


    ptk::PositionOnEarth GetSitePosition() const;

    void SetSiteInfo(ElapsedTimeStats& stats);
 


    hlcc::ambientdataclient::AmbientData& GetAmbientData();
 
 

    // 2025-07: ETCS-1916 ops-logs for received commands and state-changes
    void RecordOpsLog (const std::string &name, const std::string &value);
 
 

    DataContext(const DataContext&) = delete;       
    DataContext& operator=(const DataContext&) = delete;  
 
 private:
    Config m_config;

    ptk::IcrsCirsConverter m_conv_icrs;
 
    std::shared_ptr<OldbInterface> m_oldb_interface;
 
    bool            m_is_publishing_enabled;

    std::shared_ptr<const ::ccsinsif::PresetArgs> m_preset_args;

    ptk::EquatorialPosition m_ra_dec_target;

    ptk::EquatorialPosition m_ra_dec_target_cirs;

    bool ra_dec_target_is_valid;

    std::map<::taiclock::TaiClock::time_point, ptk::HorizonPositionEsoTimestamped> m_alt_az_target_map;

    bool m_alt_az_target_is_valid;

    ptk::HorizonPositionEsoTimestamped alt_az_current;

    EstimatedState estimated_state {EstimatedState::UNDEFINED};

    AgnosticPointingKernelPositions pointing_kernel_positions;

    hlcc::ambientdataclient::AmbientData m_ambient_data;

    bool m_site_info_published;
    bool m_site_info_first_iteration;

    mutable std::recursive_mutex m_mutex;

    std::atomic<bool> is_initialized;
};
 

constexpr const char* EstimatedStateToString(DataContext::EstimatedState state);

std::ostream& operator<<(std::ostream& os, DataContext::EstimatedState state);
 
 
}  // namespace hlcc::eltpk
 
#endif  // HLCC_TELIF_ELTPK_DATACONTEXT_HPP