MHO_MK4StationInterfaceReversed.hh

Go to the documentation of this file.

#ifndef MHO_MK4StationInterfaceReversed_HH__
#define MHO_MK4StationInterfaceReversed_HH__
 
#include <cstdlib>
#include <cstring>
 
#include <set>
#include <string>
#include <vector>
 
#include "MHO_ContainerDefinitions.hh"
#include "MHO_Message.hh"
 
#ifndef HOPS3_USE_CXX
extern "C"
{
#endif
 
    //forward declare this struct
    struct mk4_sdata;
 
#ifndef HOPS3_USE_CXX
}
#endif
 
namespace hops
{
 
class MHO_MK4StationInterfaceReversed
{
    public:
        MHO_MK4StationInterfaceReversed();
        virtual ~MHO_MK4StationInterfaceReversed();
 
        //we don't strictly need the vex file data unless we are doing a direct conversion from difx
        //since in order to fill out the type_309s, we need to know the station channel/freq set-up
        void SetVexData(const mho_json& vex_data) { fVexData = vex_data; };
 
        void SetOutputDirectory(const std::string& output_dir);
 
        void SetStationCoordData(station_coord_type* coord_data) { fStationCoordData = coord_data; }
 
        void SetPCalData(multitone_pcal_type* pcal_data) { fPCalData = pcal_data; }
 
        void SetOutputFile(const std::string& output_file) { fOutputFile = output_file; }
 
        void GenerateStationStructure();
 
        int WriteStationFile();
 
        struct mk4_sdata* GetStationStructure() { return fGeneratedStation; }
 
        void FreeAllocated();
 
    private:
        void InitializeStationStructure();
        void GenerateType000();
        std::string ConstructType000FileName();
 
        void GenerateType300();
        void GenerateType301Records();
        void GenerateType303Records();
        void GenerateType309Records();
        void setstr(const std::string& str, char* char_array, std::size_t max_size);
 
        double ComputeType309Rot(double ap_offset, std::string start_time, double start_time_mjd);
        double ComputeType309RotFallback(double ap_offset);
 
        void ConvertPhasorToCounts(const std::complex< double >& phasor, double acc_period, double sample_period,
                                   uint32_t& real_count, uint32_t& imag_count);
 
        void ExtractPCalChannelInfo();
        void ExtractPCalChannelInfoFromVex();
        double DeterminePCalToneSpacing();
 
        double FactorConvertToMHz(std::string units);
        void DetermineChannelToneIndexes(double lower_freq, double upper_freq, std::size_t& start_idx, std::size_t& ntones);
 
        std::string GetStationMode();
 
        station_coord_type* fStationCoordData;
        multitone_pcal_type* fPCalData;
        struct mk4_sdata* fGeneratedStation;
        std::string fOutputDir;
        std::string fOutputFile;
 
        //copy of vex data
        mho_json fVexData;
        std::string fStationCode;
        std::string fMode;
        std::string fFreqSetupName;
 
        // Container dimensions
        std::size_t fNCoord;
        std::size_t fNIntervals;
        std::size_t fNCoeffs;
        std::size_t fNPols;
        std::size_t fNAPs;
        std::size_t fNTones;
 
        // PCal channel information
        struct PCalChannelInfo
        {
                std::string channel_name;
                std::string polarization;
                std::string net_sideband;
                int tone_start;
                int ntones;
                int accumulator_start_index;
                double sky_freq;
                double bandwidth;
                double sample_period;
        };
 
        //the ordering operator for channel info, sort by frequency and pol
        class chan_predicate
        {
            public:
                chan_predicate(){};
                virtual ~chan_predicate(){};
 
                virtual bool operator()(const PCalChannelInfo& a, const PCalChannelInfo& b)
                {
                    if(a.sky_freq == b.sky_freq)
                    {
                        return a.polarization < b.polarization;
                    }
                    return a.sky_freq < b.sky_freq;
                }
        };
 
        std::vector< PCalChannelInfo > fPCalChannelList;
 
        std::vector< void* > fAllocated;
};
 
} // namespace hops
 
#endif