CoherentDedispersion.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2010 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/Base/Extensions/Pulsar/CoherentDedispersion.h
 
#ifndef __CoherentDedispersion_h
#define __CoherentDedispersion_h
 
#include "Pulsar/ArchiveExtension.h"
 
namespace Pulsar {
 
 
  class CoherentDedispersion : public Pulsar::Archive::Extension {
 
  public:
    
    CoherentDedispersion ();
 
    CoherentDedispersion* clone () const;
 
    TextInterface::Parser* get_interface();
 
    // Text interface to a CoherentDedispersion instance
    class Interface : public TextInterface::To<CoherentDedispersion>
    {
      public:
        Interface( CoherentDedispersion* = NULL );
    };
 
    std::string get_short_name () const { return "cd"; }
 
    //
    // OutputChannel nested class
    //
 
    class OutputChannel
    {
 
    public:
 
      double get_centre_frequency () const { return centre_frequency; }
      void set_centre_frequency (double val) { centre_frequency = val; }
 
      double get_bandwidth () const { return bandwidth; }
      void set_bandwidth (double val) { bandwidth = val; }
 
      unsigned get_nsamp () const { return nsamp; }
      void set_nsamp (unsigned val) { nsamp = val; }
 
      unsigned get_nsamp_overlap_pos () const { return nsamp_overlap_pos; }
      void set_nsamp_overlap_pos (unsigned val) { nsamp_overlap_pos = val; }
      
      unsigned get_nsamp_overlap_neg () const { return nsamp_overlap_neg; }
      void set_nsamp_overlap_neg (unsigned val) { nsamp_overlap_neg = val; }
 
    protected:
      
      double centre_frequency;
      
      double bandwidth;
      
      unsigned nsamp;
      
      unsigned nsamp_overlap_pos;
      
      unsigned nsamp_overlap_neg;
 
    };
 
    //
    // InputChannel nested class
    //
 
    class InputChannel
    {
 
    public:
 
      double get_centre_frequency () const { return centre_frequency; }
      void set_centre_frequency (double val) { centre_frequency = val; }
      
      double get_bandwidth () const { return bandwidth; }
      void set_bandwidth (double val) { bandwidth = val; }
      
      unsigned get_nchan_output () const { return output.size(); }
      void set_nchan_output (unsigned nchan) { output.resize( nchan ); }
      
      const OutputChannel& get_output (unsigned ichan_output) const;
      OutputChannel& get_output (unsigned ichan_output);
      
    protected:
      
      double centre_frequency;
      
      double bandwidth;
      
      std::vector<OutputChannel> output;
      
      void check_index (unsigned ichan_output) const;
    };
 
    //
    // CoherentDedisperion class attributes/methods
    //
 
    Signal::Dimension get_domain () const { return domain; }
    void set_domain (Signal::Dimension val) { domain = val; }
 
    std::string get_description () const { return description; }
    void set_description (const std::string& val) { description = val; }
 
    double get_dispersion_measure () const { return dispersion_measure; }
    void set_dispersion_measure (double val) { dispersion_measure = val; }
 
    double get_doppler_correction () const { return doppler_correction; }
    void set_doppler_correction (double val) { doppler_correction = val; }
 
    int get_nbit_data () const { return nbit_data; }
    void set_nbit_data (int nbit) { nbit_data = nbit; }
 
    int get_nbit_chirp () const { return nbit_chirp; }
    void set_nbit_chirp (int nbit) { nbit_chirp = nbit; }
 
    unsigned get_nchan_input () const { return input.size(); }
    void set_nchan_input (unsigned nchan) { input.resize( nchan ); }
 
    const InputChannel& get_input (unsigned ichan_input) const;
    InputChannel& get_input (unsigned ichan_input);
 
  protected:
 
    Signal::Dimension domain;
 
    std::string description;
 
    double dispersion_measure;
 
    double doppler_correction;
 
    int nbit_data;
 
    int nbit_chirp;
 
    std::vector<InputChannel> input;
 
    void check_index (unsigned ichan_input) const;
  };
 
}
 
#endif