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