dspReduction.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2003 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/Base/Extensions/Pulsar/dspReduction.h
 
#ifndef __dspReduction_h
#define __dspReduction_h
 
#include "Pulsar/ArchiveExtension.h"
 
namespace Pulsar {
 
 
  class dspReduction : public Archive::Extension {
 
  public:
    
    dspReduction ();
 
    dspReduction (const dspReduction& extension);
 
    const dspReduction& operator= (const dspReduction& extension);
 
    ~dspReduction ();
 
    dspReduction* clone () const;
 
    TextInterface::Parser* get_interface();
 
    // Text interface to a dspReduction instance
    class Interface : public TextInterface::To<dspReduction>
    {
      public:
        Interface( dspReduction *s_instance = NULL );
    };
 
    std::string get_short_name () const { return "dspsr"; }
 
    //
    // Backend implementation
    //
    
    std::string get_software () const { return software; }
 
    void set_software (const std::string& soft) { software = soft; }
 
 
    uint64_t get_total_samples () const { return total_samples; }
    void set_total_samples (uint64_t _total_samples)
    { total_samples= _total_samples; }
 
    uint64_t get_block_size () const { return block_size; }
    void set_block_size (uint64_t _block_size)
    { block_size = _block_size; }
 
    uint64_t get_overlap () const { return overlap; }
    void set_overlap (uint64_t _overlap)
    { overlap = _overlap; }
 
    Signal::State get_state () const { return state; }
    void set_state (Signal::State _state)
    { state = _state; }
 
 
 
    unsigned get_nsamp_fft () const { return nsamp_fft; }
    void set_nsamp_fft (unsigned _nsamp_fft)
    { nsamp_fft = _nsamp_fft; }
 
    unsigned get_nsamp_overlap_pos () const { return nsamp_overlap_pos; }
    void set_nsamp_overlap_pos (unsigned _nsamp_overlap_pos)
    { nsamp_overlap_pos = _nsamp_overlap_pos; }
 
    unsigned get_nsamp_overlap_neg () const { return nsamp_overlap_neg; }
    void set_nsamp_overlap_neg (unsigned _nsamp_overlap_neg)
    { nsamp_overlap_neg = _nsamp_overlap_neg; }
 
 
 
    unsigned get_nchan () const { return nchan; }
    void set_nchan (unsigned _nchan)
    { nchan = _nchan; }
 
    unsigned get_freq_res () const { return freq_res; }
    void set_freq_res (unsigned  _freq_res)
    {  freq_res= _freq_res; }
 
    unsigned get_time_res () const { return time_res; }
    void set_time_res (unsigned _time_res)
    {  time_res= _time_res; }
 
 
 
 
    unsigned get_ScrunchFactor () const { return ScrunchFactor; }
    void set_ScrunchFactor (unsigned _ScrunchFactor)
    { ScrunchFactor = _ScrunchFactor; }
 
 
 
 
    double get_scale () const { return scale; }
    void set_scale (double _scale) 
    { scale = _scale; }
 
 
 
  protected:
 
    std::string software;
 
 
    uint64_t total_samples;
 
    uint64_t block_size;
 
    uint64_t overlap;
 
    Signal::State state;
 
 
 
    unsigned nsamp_fft;
 
    unsigned nsamp_overlap_pos;
 
    unsigned nsamp_overlap_neg;
 
 
 
    unsigned nchan;
 
    unsigned freq_res;
 
    unsigned time_res;
 
 
 
 
    unsigned ScrunchFactor;
 
 
 
    double scale;
 
 
  };
 
 
}
 
#endif