PhaseSeries.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2002 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// dspsr/Signal/Pulsar/dsp/PhaseSeries.h
 
#ifndef __PhaseSeries_h
#define __PhaseSeries_h
 
#include "dsp/TimeSeries.h"
 
namespace Pulsar {
  class Predictor;
  class Parameters;
}
 
namespace dsp {
 
  class Memory;
 
  class Extensions;
  
  class PhaseSeries : public TimeSeries {
 
    friend class Fold;
    friend class CyclicFold;
    friend class PhaseLockedFilterbank;
 
  public:
 
    PhaseSeries ();
 
    PhaseSeries (const PhaseSeries&);
 
    PhaseSeries& operator = (const PhaseSeries&);
 
    ~PhaseSeries ();
 
    PhaseSeries* clone() const;
 
    virtual void resize (int64_t nsamples);
 
    void resize_hits (int64_t nbin);
 
    void combine (const PhaseSeries*);
 
    void set_reference_phase (double phase) { reference_phase = phase; }
    double get_reference_phase () const { return reference_phase; }
 
 
    void set_folding_period (double _folding_period);
    double get_folding_period () const;
 
    void set_folding_predictor (const Pulsar::Predictor*);
    const Pulsar::Predictor* get_folding_predictor () const;
    bool has_folding_predictor () const;
     
    void set_pulsar_ephemeris (const Pulsar::Parameters*);
    const Pulsar::Parameters* get_pulsar_ephemeris () const;
    bool has_pulsar_ephemeris () const;
 
    double get_integration_length () const { return integration_length; }
 
    void increment_integration_length (double seconds)
    { integration_length += seconds; }
 
    MJD get_end_time () const { return end_time; }
    void set_end_time (const MJD& mjd) { end_time = mjd; }
 
    unsigned get_nbin () const { return unsigned(get_ndat()); }
 
    unsigned get_hit (unsigned ibin, unsigned ichan=0) const;
 
    unsigned* get_hits (unsigned ichan=0);
 
    const unsigned* get_hits (unsigned ichan=0) const;
 
    uint64_t get_hits_size() const { return hits_size; }
 
    void set_hits (unsigned value);
 
    unsigned get_hits_nchan () { return hits_nchan; }
 
    void set_hits_nchan (unsigned _hits_nchan) { hits_nchan = _hits_nchan; }
 
 
    MJD get_mid_time (bool phased = true) const;
 
    void zero ();
 
    bool combinable_rate (double) const { return true; }
 
    void set_ndat_expected (uint64_t);
 
    uint64_t get_ndat_expected () const;
 
    uint64_t get_ndat_total () const;
 
    uint64_t get_ndat_folded () const;
 
    uint64_t get_ndat_folded (unsigned ichan) const;
 
    void set_extensions (Extensions*);
    const Extensions* get_extensions () const;
    Extensions* get_extensions ();
 
    bool has_extensions () const;
 
    virtual void copy_configuration (const Observation* copy);
 
    void set_hits_memory (Memory*);
 
    const Memory* get_hits_memory () const;
 
  protected:
 
    double folding_period;
 
    Reference::To<const Pulsar::Predictor> folding_predictor;
 
    Reference::To<const Pulsar::Parameters> pulsar_ephemeris;
 
    Reference::To<Extensions> extensions;
 
    double reference_phase;
 
    unsigned * hits;
 
    unsigned hits_nchan;
 
    uint64_t hits_size;
 
    uint64_t ndat_total;
 
    uint64_t ndat_expected;
 
    double integration_length;
 
    MJD end_time;
 
    bool mixable (const Observation& obs, unsigned nbin,
                  int64_t istart=0, int64_t fold_ndat=0);
 
    Reference::To<Memory> hits_memory;
 
  private:
 
    void operator += (const PhaseSeries&);
 
    void init ();
    void copy_attributes (const PhaseSeries*);
 
  };
 
}
 
#endif