Header.h

Go to the documentation of this file.

/*
 * MIT License
 *
 * Copyright (c) 2018 PulsarSearchSoft
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
#ifndef PSS_ASTROTYPES_SIGPROC_HEADER_H
#define PSS_ASTROTYPES_SIGPROC_HEADER_H

#include "HeaderField.h"
#include "detail/HeaderFieldDataType.h"
#include "detail/HeaderBase.h"
#include "pss/astrotypes/utils/Optional.h"
#include "pss/astrotypes/units/Time.h"
#include "pss/astrotypes/units/Frequency.h"
#include "pss/astrotypes/units/Angle.h"
#include "pss/astrotypes/units/DispersionMeasure.h"
#include "pss/astrotypes/types/TimeFrequency.h"

namespace pss {
namespace astrotypes {
namespace sigproc {

class Header : public HeaderBase<Header>
{
    private:
        typedef HeaderBase<Header> BaseT;
        typedef Header SelfType;

        template<typename T>
        class OStreamAdapter {
            public:
                OStreamAdapter(Header const& h, T const& data);
                std::ostream& operator<<(std::ostream& os) const;
            private:
                Header const& _h;
                T const& _d;
        };

        friend class HeaderFieldBase;

        template<typename T>
        friend class HeaderFieldDataType;

    public:
        using HeaderBase<Header>::Info;

        enum class DataType {
            Undefined  = 0,
            FilterBank = 1, // stored as a series of spectra
            TimeSeries      // stored as a series of channels
        };

    public:
        Header();
        Header(Header const&);
        virtual ~Header() {};

        Header& operator=(Header const&);

        utils::Optional<unsigned> telescope_id() const;

        void telescope_id(unsigned id);

        utils::Optional<unsigned> machine_id() const;

        void machine_id(unsigned id);

        void data_type(DataType type);

        DataType data_type() const;

        utils::Optional<std::string> const& raw_data_file() const;

        void raw_data_file(std::string const& name);

        utils::Optional<std::string> const& source_name() const;

        void source_name(std::string const& name);

        utils::Optional<unsigned> const& barycentric() const;
        void barycentric(bool barycentric);

        utils::Optional<unsigned> const& pulsarcentric() const;
        void pulsarcentric(bool pulsarcentric);

        utils::Optional<boost::units::quantity<units::Degree, double>> az_start() const;
        void az_start(boost::units::quantity<units::Degree, double> const&);

        utils::Optional<boost::units::quantity<units::Degree, double>> za_start() const;
        void za_start(boost::units::quantity<units::Degree, double> const&);

        utils::Optional<units::ModifiedJulianDate> const& tstart() const;

        void tstart(units::ModifiedJulianDate const&);

        boost::units::quantity<units::Seconds, double> sample_interval() const;

        void sample_interval(boost::units::quantity<units::Seconds, double>);

        utils::Optional<boost::units::quantity<units::MegaHertz, double>> const& fch1() const;

        void fch1(boost::units::quantity<units::MegaHertz, double> const&);

        utils::Optional<boost::units::quantity<units::MegaHertz, double>> const& foff() const;

        void foff(boost::units::quantity<units::MegaHertz, double> const&);

        std::vector<boost::units::quantity<units::MegaHertz, double>> const& frequency_channels() const;

        void frequency_channels(std::vector<boost::units::quantity<units::MegaHertz, double>> const& frequency_channels);

        DimensionSize<units::Frequency> number_of_channels() const;

        void number_of_channels(std::size_t);
        void number_of_channels(DimensionSize<units::Frequency>);

        unsigned number_of_bits() const;

        void number_of_bits(unsigned);

        utils::Optional<unsigned> const& number_of_samples() const;

        void number_of_samples(unsigned);

        unsigned number_of_ifs() const;

        void number_of_ifs(unsigned);

        utils::Optional<units::DispersionMeasure<double>> const& ref_dm() const;

        void ref_dm(units::DispersionMeasure<double>);

        utils::Optional<boost::units::quantity<units::Seconds, double>> const& period() const;

        void period(boost::units::quantity<units::Seconds, double>);

        utils::Optional<unsigned> ibeam() const;

        utils::Optional<unsigned> nbeams() const;

        template<typename T, typename Alloc>
        SelfType& operator>>(astrotypes::FrequencyTime<T, Alloc> const&) const;

        template<typename T, typename Alloc>
        SelfType& operator>>(astrotypes::TimeFrequency<T, Alloc> const&) const;

        template<typename T, typename Alloc>
        SelfType& operator<<(astrotypes::FrequencyTime<T, Alloc> const&) const;

        template<typename T, typename Alloc>
        OStreamAdapter<astrotypes::TimeFrequency<T, Alloc>> operator<<(astrotypes::TimeFrequency<T, Alloc> const&);

        void info(std::ostream& stream) const;

    protected:
        void updated_data_type();

    private:
        // standard header data fields
        HeaderField<unsigned>           _telescope_id;
        HeaderField<unsigned>           _machine_id;
        HeaderFieldDataType<unsigned>           _data_type;
        HeaderField<std::string>        _raw_data_file;
        HeaderField<std::string>        _source_name;
        HeaderField<unsigned>           _barycentric;
        HeaderField<unsigned>           _pulsarcentric;
        HeaderField<boost::units::quantity<units::Degree, double>>  _az_start;  // in degrees
        HeaderField<boost::units::quantity<units::Degree, double>>  _za_start;  // in degrees
        HeaderField<double>             _src_raj;                               // right ascension (J2000) of source (hhmmss.s)
        HeaderField<double>             _src_dej;                               // declination (J2000) of source (ddmmss.s)
        HeaderField<boost::units::quantity<units::Seconds, double>>        _tsamp;     // sample time (in seconds)
        HeaderFieldWithTolerance<units::ModifiedJulianDate, decltype(_tsamp) const&>   _tstart;    // Modified Julian Date format
        HeaderField<unsigned>                                              _n_bits;
        HeaderField<unsigned>                                              _nsamples;
        HeaderField<boost::units::quantity<units::MegaHertz, double>>      _fch1;
        HeaderField<boost::units::quantity<units::MegaHertz, double>>      _foff;
        HeaderField<std::vector<boost::units::quantity<units::MegaHertz, double>>>   _freq_channels; // each bin assigned its own value
        HeaderField<unsigned>                                              _n_chans;
        HeaderField<unsigned>                                              _nifs;        // number of seperate IF channels
        HeaderField<units::DispersionMeasure<double>>                      _refdm;       // parsecs_per_cm_cubed
        HeaderField<boost::units::quantity<units::Seconds, double>>        _period;      // folding period seconds

        // these fielde are not standard but added here to allow parsing
        HeaderField<unsigned>       _ibeam;      // the beam index
        HeaderField<unsigned>       _nbeams;     // the total number of beams in the observation
};

template<typename Stream>
Header::InfoSentry<Stream> operator<<(Stream& os, Header::Info const&);

} // namespace sigproc
} // namespace astrotypes
} // namespace pss
#include "detail/Header.cpp"

#endif // PSS_ASTROTYPES_SIGPROC_HEADER_H