Fold.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2002-2010 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// dspsr/Signal/Pulsar/dsp/Fold.h
 
#ifndef __baseband_dsp_Fold_h
#define __baseband_dsp_Fold_h
 
#include "dsp/Transformation.h"
#include "dsp/TimeSeries.h"
#include "dsp/PhaseSeries.h"
 
namespace Pulsar
{
  class Predictor;
  class Parameters;
}
 
namespace dsp
{
  class WeightedTimeSeries;
  class ObservationChange;
 
 
  class Fold : public Transformation <TimeSeries, PhaseSeries>
  {
    friend class MultiFold;
 
  public:
    
    static unsigned maximum_nbin;
 
    static double minimum_bin_width;
 
    static bool power_of_two;
 
    Fold ();
    
    ~Fold ();
 
    virtual Fold* clone () const;
 
    PhaseSeries* get_output () const;
 
    virtual void prepare ();
 
    void prepare (const Observation* observation);
 
    void combine (const Operation*);
 
    void reset ();
 
    virtual void finish ();
 
    uint64_t bytes_storage() const override;
    
    PhaseSeries* get_result () const;
 
    void set_nbin (unsigned _nbin) { requested_nbin = _nbin; }
    unsigned get_nbin () const { return requested_nbin; }
 
    void set_force_sensible_nbin (bool _force_sensible) { force_sensible_nbin = _force_sensible; }
    bool get_force_sensible_nbin () { return force_sensible_nbin; }
 
    void set_ncoef (unsigned ncoef);
    unsigned get_ncoef () const { return ncoef; }
 
    void set_nspan (unsigned nspan);
    unsigned get_nspan () const { return nspan; }
 
    void set_change (const ObservationChange*);
 
 
    void set_folding_period (double folding_period);
 
    void set_reference_epoch (const MJD&);
 
    double get_folding_period () const;
 
    bool has_folding_period() const { return (folding_period>0); }
 
    const Pulsar::Predictor* get_folding_predictor () const;
 
    bool has_folding_predictor () const;
 
    const Pulsar::Parameters* get_pulsar_ephemeris () const;
 
    void set_folding_predictor (const Pulsar::Predictor*);
 
    bool has_pulsar_ephemeris() const { return pulsar_ephemeris.ptr(); }
 
    void set_pulsar_ephemeris (const Pulsar::Parameters*);
 
    virtual void set_reference_phase (double phase);
    double get_reference_phase () const { return reference_phase; }
 
    void set_input (const TimeSeries* input);
 
    unsigned choose_nbin (bool quiet = false) const;
 
    class Engine;
 
    virtual void set_engine (Engine*);
 
    virtual void set_cerr (std::ostream& os) const;
 
    virtual Engine * get_engine() { return engine; }
 
  protected:
 
    virtual void transformation ();
 
    virtual void fold (uint64_t nweights, const unsigned* weights,
                       unsigned ndatperweight, unsigned weight_idat);
 
    virtual void set_limits (const Observation* input);
 
    virtual void check_input();
 
    virtual void prepare_output();
 
    void set_idat_start(uint64_t _idat_start){ idat_start = _idat_start; }
    uint64_t get_idat_start(){ return idat_start; }
    void set_ndat_fold(uint64_t _ndat_fold){ ndat_fold = _ndat_fold; }
    uint64_t get_ndat_fold(){ return ndat_fold; }
 
    double get_pfold (const MJD& start_time);
    
    double get_phi (const MJD& start_time);
 
    double folding_period;
 
    Reference::To<const WeightedTimeSeries> weighted_input;
 
    unsigned folding_nbin;
 
    unsigned requested_nbin;
 
    bool force_sensible_nbin;
 
    double reference_phase;
 
    MJD reference_epoch;
 
    unsigned ncoef;
 
    unsigned nspan;
 
    Reference::To<const ObservationChange> change;
 
    bool built;
 
    uint64_t idat_start;
 
    uint64_t ndat_fold;
 
    // This is called from prepare() rather than the constructor so that reducer
    // can set parameters (globally) if they have not been initialised locally for a given
    // dsp::Fold
    void initialise();
 
    Reference::To<Engine> engine;
 
  private:
 
    // Generates folding_predictor from the given ephemeris
    Pulsar::Predictor* get_folding_predictor (const Pulsar::Parameters*,
                                              const Observation*);
 
    Reference::To<const Pulsar::Predictor> folding_predictor;
 
    Reference::To<const Pulsar::Parameters> pulsar_ephemeris;
 
    double pfold;
 
  };
 
  class Fold::Engine : public OwnStream
  {
  public:
 
    void set_parent (Fold*);
 
    virtual void set_nbin (unsigned nbin) = 0;
 
    virtual void set_bin (uint64_t idat, double ibin, double bins_per_samp) = 0;
 
    // Alternative fucntion to setup binplan all at once, rather than point by point
    virtual uint64_t set_bins (double phi, double phase_per_sample, uint64_t _ndat, uint64_t idat_start)=0;
    // Set this property true to use set_bins instead of set_bin
    bool use_set_bins;
    // fuction used when set_bins is used to update the number of hits in each bin
    virtual uint64_t get_bin_hits (int ibin)=0;
 
    virtual uint64_t get_ndat_folded () const = 0;
 
    virtual PhaseSeries* get_profiles () = 0;
 
    virtual void fold () = 0;
 
    virtual void synch (PhaseSeries*) = 0;
 
    virtual void zero () = 0;
 
    virtual void set_ndat (uint64_t ndat, uint64_t idat_start) {}
 
  protected:
 
    float* output;
    unsigned output_span;
 
    const float* input;
    unsigned input_span;
 
    unsigned* hits;
    unsigned hits_nchan;
    bool zeroed_samples;
 
    unsigned ndat_fold;
    uint64_t idat_start;
 
    unsigned nchan, npol, ndim;
 
    void setup ();
 
    Fold* parent;
 
    bool synchronized;
  }; 
 
}
 
#endif // !defined(__Fold_h)