MHO_AdhocFlagging.hh

Go to the documentation of this file.

#ifndef MHO_AdhocFlagging_HH__
#define MHO_AdhocFlagging_HH__
 
#include <array>
#include <cstdint>
#include <string>
#include <vector>
 
#include "MHO_Clock.hh"
#include "MHO_Message.hh"
 
#include "MHO_ContainerDefinitions.hh"
#include "MHO_ParameterStore.hh"
#include "MHO_TableContainer.hh"
#include "MHO_UnaryOperator.hh"
 
namespace hops
{
 
class MHO_AdhocFlagging: public MHO_UnaryOperator< weight_type >
{
    public:
        MHO_AdhocFlagging();
        virtual ~MHO_AdhocFlagging();
 
        void SetRefFlagFile(const std::string& filename) { fFlagFile[0] = filename; }
 
        void SetRemFlagFile(const std::string& filename) { fFlagFile[1] = filename; }
 
        const std::string& GetRefFlagFile() const { return fFlagFile[0]; }
 
        const std::string& GetRemFlagFile() const { return fFlagFile[1]; }
 
        void SetParameterStore(MHO_ParameterStore* pstore) { fParameterStore = pstore; }
 
    protected:
        virtual bool InitializeInPlace(weight_type* in) override;
        virtual bool InitializeOutOfPlace(const weight_type* in, weight_type* out) override;
        virtual bool ExecuteInPlace(weight_type* in) override;
 
    private:
        // Maximum number of frequency channels encoded per flag file row.
        static constexpr std::size_t MAX_FLAG_FREQS = 64;
 
        // Bit masks for USB/LSB channel retention checks.
        //
        // NOTE: These follow the *legacy fourfit (adhoc_flag.c) convention*,
        // where the C variable names are inverted relative to the flag-file
        // bit-assignment documentation:
        //   doc bit layout (msb->lsb): USB-RL,LSB-RL,USB-LR,LSB-LR,USB-RR,LSB-RR,USB-LL,LSB-LL
        //   doc USB bits: 0xAA (bits 7,5,3,1),  doc LSB bits: 0x55 (bits 6,4,2,0)
        //
        // However in the legacy code:
        //   usb_flag = ref & rem & 0x55  (tests the doc-LSB bits to gate USB data)
        //   lsb_flag = ref & rem & 0xAA  (tests the doc-USB bits to gate LSB data)
        //
        // We preserve this inversion so that existing flag files, which were
        // written to match the legacy tool's behavior, continue to work correctly.
        //
        // Practical effect: a flag byte of 0x80 zeros USB channels and retains LSB,
        // even though bit 7 is labelled "USB-RL" in the documentation.
        static constexpr uint8_t USB_MASK = 0x55u; // legacy "usb_flag" mask
        static constexpr uint8_t LSB_MASK = 0xAAu; // legacy "lsb_flag" mask
 
        struct FlagTableRow
        {
                double time_fpday;
                std::array< uint8_t, MAX_FLAG_FREQS > bytes;
        };
 
        static void DecodeHexToken(const char* hex_token, std::array< uint8_t, MAX_FLAG_FREQS >& bytes);
 
        bool LoadFlagFile(std::size_t stn_idx);
 
        const uint8_t* LookupFlagBytes(std::size_t stn_idx, double ap_center_fpday) const;
 
        // Optional parameter store for updating /fringe/total_summed_weights
        MHO_ParameterStore* fParameterStore;
 
        // Flag file paths: [0] = ref, [1] = rem
        std::string fFlagFile[2];
 
        // Parsed flag tables: [0] = ref, [1] = rem
        std::vector< FlagTableRow > fFlagTable[2];
 
        // Scan timing (filled during InitializeInPlace)
        double fScanStartFpDay; // scan start as fractional days since BOY
        int fScanYear;          // year of scan start
        double fAccPeriod;      // accumulation period in seconds
 
        // Metadata key names
        std::string fStartKey;    // "start"
        std::string fSidebandKey; // "net_sideband"
};
 
} // namespace hops
 
#endif