Observation.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2002 - 2023 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
#ifndef __Observation_h
#define __Observation_h
 
#include "environ.h"
#include "dsp/dsp.h"
 
#include "OwnStream.h"
#include "sky_coord.h"
#include "Types.h"
#include "MJD.h"
#include "Rational.h"
#include "dsp/FIRFilter.h"
 
#include <vector>
 
// forward declaration of text interface
namespace TextInterface
{
  class Parser;
};
 
namespace dsp
{
  class Observation : public OwnStream
  {
 
  public:
 
    static bool verbose;
 
    Observation ();
 
    Observation (const Observation&);
 
    Observation (const Observation*);
 
    const Observation& operator = (const Observation&);
 
    virtual ~Observation();
 
    virtual void copy (const Observation* obs) { operator=( *obs ); }
 
    virtual Observation* clone() const;
 
    virtual void set_basis (Signal::Basis _basis) { basis = _basis; }
    Signal::Basis get_basis () const { return basis; }
 
    virtual void set_state (Signal::State _state);
    Signal::State get_state () const { return state; }
 
    virtual void set_type (Signal::Source _type) { type = _type; }
    Signal::Source get_type () const { return type; }
 
    virtual void set_ndim (unsigned _ndim) { ndim = _ndim; }
    unsigned get_ndim () const { return ndim; }
 
    virtual void set_nchan (unsigned _nchan) { nchan = _nchan; }
    unsigned get_nchan () const { return nchan; }
 
    virtual void set_npol (unsigned _npol) { npol = _npol; }
    unsigned get_npol () const { return npol; }
 
    virtual void set_nbit (unsigned _nbit) { nbit = _nbit; }
    unsigned get_nbit () const { return nbit; }
 
    uint64_t bits_per_sample () const;
 
 
    virtual void set_ndat (uint64_t _ndat) { ndat = _ndat; }
    uint64_t get_ndat () const { return ndat; }
 
    virtual void set_telescope (const std::string& name) { telescope = name; }
    std::string get_telescope () const { return telescope; }
 
    virtual void set_receiver (const std::string& name) { receiver = name; }
    std::string get_receiver () const { return receiver; }
 
    virtual void set_source (const std::string& name) { source = name; }
    std::string get_source () const { return source; }
 
    virtual void set_coordinates (sky_coord _coordinates)
    { coordinates=_coordinates; }
    sky_coord get_coordinates () const
    { return coordinates; }
 
    virtual void set_centre_frequency (double cf) { centre_frequency = cf; }
    double get_centre_frequency () const{ return centre_frequency; }
 
    double get_centre_frequency (unsigned ichan) const;
    double get_base_frequency () const;
 
    unsigned get_unswapped_ichan (unsigned ichan) const;
 
    virtual void set_bandwidth (double _bandwidth) { bandwidth = _bandwidth; }
    double get_bandwidth () const { return bandwidth; }
 
    virtual void set_start_time (MJD _start_time) { start_time = _start_time; }
    MJD get_start_time () const { return start_time; }
 
    virtual void set_rate (double _rate) { rate = _rate; }
    double get_rate () const { return rate; }
 
    virtual void set_scale (double _scale) { scale = _scale; }
    double get_scale () const { return scale; }
 
    virtual void set_swap (bool _swap) { swap = _swap; }
    bool get_swap () const { return swap; }
 
    virtual void set_nsub_swap (unsigned _nsub) { nsub_swap = _nsub; }
    unsigned get_nsub_swap () const { return nsub_swap; }
 
 
    virtual void set_dual_sideband (int _dual);
    int get_dual_sideband () const;
 
 
    virtual void set_dc_centred (bool _centred) { dc_centred = _centred; }
    bool get_dc_centred () const { return dc_centred; }
 
    virtual void set_identifier (const std::string& _id) { identifier = _id; }
    std::string get_identifier () const { return identifier; }
 
    virtual void set_machine (const std::string& _m) { machine = _m; }
    std::string get_machine () const { return machine; }
 
    virtual void set_format (const std::string& _f) { format = _f; }
    std::string get_format () const { return format; }
 
    virtual void set_dispersion_measure (double dm)
    { dispersion_measure = dm; }
    double get_dispersion_measure () const { return dispersion_measure; }
 
    virtual void set_rotation_measure (double rm)
    { rotation_measure = rm; }
    double get_rotation_measure () const
    { return rotation_measure; }
 
    virtual void set_mode (const std::string& _mode) { mode = _mode; }
    std::string get_mode () const { return mode; }
 
    virtual void set_calfreq (double _calfreq) {calfreq = _calfreq;}
    double get_calfreq() const {return calfreq;}
 
    virtual void set_oversampling_factor (const Rational& _osf)
    { oversampling_factor = _osf; }
 
    const Rational& get_oversampling_factor () const
    { return oversampling_factor; }
 
    virtual void set_deripple (const std::vector<dsp::FIRFilter>& _deripple)
    { deripple = _deripple; }
 
    const std::vector<dsp::FIRFilter>& get_deripple () const { return deripple; }
 
    // get the number of derippling stages,
    // or the number of upsteam layers of channelization
    unsigned get_deripple_stages () const { return deripple.size(); }
 
    virtual void set_pfb_dc_chan (const bool _pfb_dc_chan) { pfb_dc_chan = _pfb_dc_chan; }
 
    bool get_pfb_dc_chan () const { return pfb_dc_chan; }
 
    virtual void set_pfb_nchan (unsigned nchan) { pfb_nchan = nchan; }
    unsigned get_pfb_nchan () const { return pfb_nchan; }
 
    virtual void change_state (Signal::State new_state);
 
    bool state_is_valid (std::string& reason) const;
 
    bool get_detected () const;
 
    void change_start_time (int64_t _ndat);
 
    // Returns correct answer if ndat=rate=0 and avoids division by zero
    virtual MJD get_end_time () const;
 
    uint64_t get_idat (const MJD& mjd);
 
    void rescale (double factor) { scale *= factor; }
 
    virtual uint64_t get_nbytes (uint64_t nsamples) const;
 
    uint64_t get_nbytes () const
      { return get_nbytes (get_ndat()); }
 
    uint64_t verbose_nbytes (uint64_t nsamples) const;
 
    float get_nbyte () const;
 
    virtual uint64_t get_nsamples (uint64_t nbytes) const;
 
    void copy_dimensions (const Observation*);
 
    bool combinable (const Observation& obs) const;
 
    std::string get_reason () { return reason; }
 
    bool contiguous (const Observation& next) const;
 
    void init ();
 
    class NbyteNsamplePolicy;
 
    void set_nbyte_nsample_policy (NbyteNsamplePolicy*);
 
    const NbyteNsamplePolicy* get_nbyte_nsample_policy () const;
 
    class Interface;
 
    virtual TextInterface::Parser* get_interface ();
 
  protected:
 
    std::string telescope;
 
    std::string receiver;
 
    std::string source;
 
    double centre_frequency = 0.0;
 
    double bandwidth = 0.0;
 
    Signal::Source type;
 
    Signal::State state;
 
    Signal::Basis basis;
 
    double rate = 0.0;
 
    MJD start_time;
 
    std::string identifier;
 
    std::string mode;
 
    std::string machine;
 
    std::string format;
 
    sky_coord coordinates;
 
    double dispersion_measure = 0.0;
 
    double rotation_measure = 0.0;
 
    bool require_equal_sources = true;
 
    bool require_equal_rates = true;
 
    double scale = 1.0;
 
    bool swap = false;
 
    unsigned nsub_swap = 0;
 
    bool dc_centred = false;
 
    Rational oversampling_factor;
 
    std::vector<FIRFilter> deripple;
 
    bool pfb_dc_chan = true;
 
 
    unsigned pfb_nchan = 0;
 
  private:
 
    //
    // Private variables should be accessed only using set/get at all times!
    //
 
 
    uint64_t ndat = 0;
 
 
    unsigned ndim = 1;
 
    unsigned nchan = 1;
 
    unsigned npol = 1;
 
    unsigned nbit = 0;
 
    double calfreq = 0.0;
 
 
    int dual_sideband = 0;
 
    bool dual_sideband_set = false;
 
    mutable std::string reason;
 
    Reference::To<NbyteNsamplePolicy> nbyte_nsample_policy;
  };
 
  class Observation::NbyteNsamplePolicy : public Reference::Able
  {
  public:
 
    Observation* obs = nullptr;
 
    virtual NbyteNsamplePolicy* clone () const;
 
    virtual uint64_t get_nbytes (uint64_t nsamples) const;
 
    virtual uint64_t get_nsamples (uint64_t nbytes) const;
 
    uint64_t bits_per_sample () const;
  };
 
}
 
#ifdef ACTIVATE_MPI
 
#include <mpi.h>
 
int mpiPack_size (const dsp::Observation&, MPI_Comm comm, int* size);
 
int mpiPack (const dsp::Observation&,
             void* outbuf, int outcount, int* position, MPI_Comm comm);
 
int mpiUnpack (void* inbuf, int insize, int* position,
               dsp::Observation*, MPI_Comm comm);
 
#endif
 
#endif // ! __Observation_h