pubFits.hpp

Go to the documentation of this file.

 
#ifndef CCF_STDPUB_PUB_FITS_HPP_H_
#define CCF_STDPUB_PUB_FITS_HPP_H_
 
#include <fitsio.h>
#include <CCfits/CCfits.h>
#include <CCfits/FITS.h>
#include <CCfits/PHDU.h>
 
#include <dit/fits/fits.hpp>
 
#include "ccf/common/pubBase.hpp"
 
namespace ccf::stdpub {
 
  class PubFits: public ccf::common::PubBase {
  public:
 
    static bool s_initialised;
    static char s_padding_bytes[2880];
 
    // Setup keys.
    const std::string SETUP_KEY_BASENAME     = "proc%d.pub%d.basename";
    const std::string SETUP_KEY_MAX_SIZE     = "proc%d.pub%d.max_size";
    const std::string SETUP_KEY_NB_OF_FRAMES = "proc%d.pub%d.nb_of_frames";
    const std::string SETUP_KEY_FORMAT       = "proc%d.pub%d.format";
    const std::string SETUP_KEY_OVERWRITE    = "proc%d.pub%d.overwrite";
    const std::string SETUP_KEY_REC_MODE     = "proc%d.pub%d.rec_mode";
 
    enum class Format {
      SINGLE = 1,
      CUBE,
      MEF
    };
 
    const std::string FORMAT_SINGLE    = "Single";
    const std::string FORMAT_CUBE      = "Cube";
    const std::string FORMAT_MEF       = "MEF";
 
    enum class RecordingMode {
        ALL = 1,
        INTERVAL,
        PERIODIC
    };
 
    const std::string RECORDING_MODE_ALL      = "ALL";
    const std::string RECORDING_MODE_INTERVAL = "INTERVAL";
    const std::string RECORDING_MODE_PERIODIC = "PERIODIC";
 
    PubFits(const uint16_t proc_thread_nb,
            const uint16_t pub_thread_nb,
            const std::string& pub_name);
 
    PubFits();
 
    virtual ~PubFits();
 
    virtual void InitialiseUser();
 
    virtual void PublishUser(ccf::common::DataFrame& frame);
 
    virtual void CheckForDeactivationUser();
    
    virtual void ActivateUser();
 
    virtual void DeactivateUser();
 
    virtual void CreateObjectUser(const uint16_t proc_thread_nb,
                                  const uint16_t pub_thread_nb,
                                  const std::string& pub_name,
                                  ccf::common::PubBase** new_object);
 
    virtual void EstimateExecutionUser(double& duration,
                                       int64_t& nb_of_frames);
 
    Format        FormatToNb(const std::string& format);
 
    std::string   FormatToStr(const Format format);
 
    void          DecodeRecMode(const std::string& rec_mode_specifier);
 
    std::string   RecordingModeToStr(const RecordingMode mode);
  
  protected:
 
  private:
    void StoreImage_(ccf::common::DataFrame& frame);
    void AddStdKeys_(ccf::common::DataFrame& frame);
 
    // Setup parameters.
    std::string            m_setup_file_basename;
    int32_t                m_setup_max_size;
    int32_t                m_setup_nb_of_frames;
    Format                 m_setup_format;
    bool                   m_setup_overwrite;
    RecordingMode          m_setup_rec_mode; 
    int32_t                m_setup_frame_interval;
    double                 m_setup_frame_period;
    ccf::common::ExpoMode  m_setup_expo_mode;
    int32_t                m_setup_expo_nb;
 
    std::string            m_stat_cur_filename;
    std::string            m_stat_prev_filename;
 
    int32_t                m_stat_frames_stored;
    double                 m_stat_last_frame_storage_time;
    int32_t                m_stat_size_frames_stored;
 
    // Total number of frames made available to this Data Publisher.
    uint32_t               m_stat_frame_count;
 
    std::shared_ptr<CCfits::FITS> m_fits_handle;
 
    // Fix metadata values.
    std::string      m_det_system;
    std::string      m_det_cam_name;
    std::string      m_det_cam_id;
    std::string      m_det_cam_model;
    std::string      m_det_cam_chip_model;
    std::string      m_det_cam_type;
  };
 
}
 
#endif // CCF_STDPUB_PUB_FITS_HPP_H_