TimeDivide.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2005 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// dspsr/Signal/Pulsar/dsp/TimeDivide.h
 
#ifndef __baseband_dsp_TimeDivide_h
#define __baseband_dsp_TimeDivide_h
 
#include "environ.h"
#include "Pulsar/Predictor.h"
#include "OwnStream.h"
 
namespace dsp {
 
  class Observation;
 
  class TimeDivide : public OwnStream {
 
  public:
    
    TimeDivide ();
 
    ~TimeDivide ();
 
 
    void set_start_time (MJD start_time);
 
    MJD get_start_time () const { return start_time; }
 
    void set_seconds (double division_seconds);
 
    double get_seconds () const { return division_seconds; }
 
    void set_reference_epoch (const MJD& epoch) { reference_epoch = epoch; }
 
    MJD get_reference_epoch () const { return reference_epoch; }
 
    void set_turns (double division_turns);
 
    double get_turns () const { return division_turns; }
 
    void set_predictor (const Pulsar::Predictor*);
 
    const Pulsar::Predictor* get_predictor () const { return poly; }
 
    void set_period (double);
 
    double get_period () const { return period; }
 
    void set_reference_phase (double phase);
 
    double get_reference_phase () const { return reference_phase; }
 
    void set_fractional_pulses (bool);
    bool get_fractional_pulses () const;
 
 
 
    void set_bounds (const Observation*);
 
    void discard_bounds (const Observation*);
    
    bool get_is_valid () const { return is_valid; }
 
    bool get_new_division () const { return new_division; }
 
    bool get_in_next () const { return in_next; }
 
    bool get_end_reached () const { return end_reached; }
 
    uint64_t get_idat_start () const { return idat_start; }
 
    uint64_t get_ndat () const { return ndat; }
 
    uint64_t get_division_ndat () const { return division_ndat; }
 
    unsigned get_phase_bin () const { return phase_bin; }
 
    uint64_t get_division () const { return division; }
 
    uint64_t get_division (const MJD& epoch);
 
 
  protected:
 
    MJD start_time;
 
    Pulsar::Phase start_phase;
 
    double division_seconds = 0;
 
    MJD reference_epoch;
 
    double division_turns = 0;
 
    double reference_phase = 0;
 
    bool fractional_pulses = false;
 
    bool integer_division_seconds_boundaries = true;
 
    double period = 0;
 
    Reference::To<const Pulsar::Predictor> poly;
 
    void set_boundaries (const MJD& time);
 
    void set_boundaries (const MJD& mjd1, const MJD& mjd2);
 
  private:
 
    MJD lower;
 
    MJD upper;
 
    MJD current_end;
 
    uint64_t division = 0;
 
    bool is_valid = false;
 
    bool in_next = false;
 
    bool end_reached = false;
 
    bool new_division = false;
 
    mutable const Observation* observation;
 
    uint64_t idat_start = 0;
 
    uint64_t ndat = 0;
 
    uint64_t division_ndat = 0;
 
    unsigned phase_bin = 0;
 
  };
 
}
 
#endif // !defined(__SubFold_h)