Response.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2002 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// dspsr/Signal/General/dsp/Response.h
 
#ifndef __Response_h
#define __Response_h
 
#include <vector>
#include <complex>
#include <string>
 
#include "dsp/Shape.h"
#include "Callback.h"
#include "Jones.h"
#include "Rational.h"
 
namespace dsp {
 
  class Observation;
  class OptimalFFT;
 
  class Response : public Shape {
 
  public:
 
    static unsigned ndat_max;
 
    Response();
 
    virtual ~Response ();
 
    Response (const Response&);
 
    const Response& operator = (const Response&);
 
    const Response& operator *= (const Response&);
 
    virtual void prepare (const Observation* input, unsigned channels=0);
 
    virtual void match (const Observation* input, unsigned channels=0);
 
    virtual void match (const Response* response);
 
    unsigned get_input_nchan () const { return input_nchan; }
 
    void set_input_nchan (unsigned _input_nchan) { input_nchan = _input_nchan; }
 
 
    unsigned get_impulse_pos () const { return impulse_pos; }
 
 
    unsigned get_impulse_neg () const { return impulse_neg; }
 
 
    void set_impulse_pos (unsigned _impulse_pos) { impulse_pos =_impulse_pos; }
 
 
    void set_impulse_neg (unsigned _impulse_neg) { impulse_neg =_impulse_neg; }
 
    virtual void set_dc_centred (bool dc_centred);
 
    bool get_dc_centred () const { return dc_centred; }
 
    virtual void set_swap (bool flag) { whole_swapped = flag; }
 
    bool get_swap () const { return whole_swapped; }
 
    unsigned get_minimum_ndat () const;
 
    void set_optimal_ndat ();
 
    void set_optimal_fft (OptimalFFT*);
    OptimalFFT* get_optimal_fft () const;
    bool has_optimal_fft () const;
 
    void check_ndat () const;
 
    std::vector<float> get_passband (unsigned ipol, int ichan=-1) const;
 
    void set (const std::vector<std::complex<float> >& phasors);
 
    void set (const std::vector<Jones<float> >& jones);
 
    void operate (float* spectrum, unsigned poln=0, int ichan=-1) const;
 
    void operate (float* spectrum, unsigned poln,
                  int ichan_start, unsigned nchan_op) const;
 
    void operate (float* input_spectrum, float * output_spectrum,
                  unsigned poln, int ichan_start, unsigned nchan_op) const;
 
    void operate (float* spectrum1, float* spectrum2, int ichan=-1) const;
 
    void integrate (float* spectrum, unsigned poln=0, int ichan=-1);
 
    void integrate (float* spectrum1, float* spectrum2, int ichan=-1);
 
    virtual bool matches (const Shape* response);
 
    virtual void mark (Observation* output);
 
    void naturalize ();
 
    virtual bool state_is_valid (std::string& reason) { return true; }
 
    Callback<Response> changed;
 
    void flagswap (unsigned divisions = 1);
 
    float get_nbyte () const { return 0; }
 
    void check_finite (const char* name);
 
  protected:
 
    void calc_lcf (unsigned a, unsigned b, const Rational& osf, std::vector<unsigned>& result);
 
    void calc_oversampled_discard_region(
      unsigned* _discard_neg,
      unsigned* _discard_pos,
      unsigned _nchan,
      const Rational& osf);
 
    void calc_oversampled_fft_length(
      unsigned* _fft_length,
      unsigned _nchan,
      const Rational& osf,
      int direction=-1);
 
 
    mutable unsigned step;
 
    Reference::To<OptimalFFT> optimal_fft;
 
    void doswap (unsigned divisions = 1);
 
    unsigned impulse_pos;
 
    unsigned impulse_neg;
 
    bool whole_swapped;
 
    unsigned swap_divisions;
 
    bool dc_centred;
 
    unsigned input_nchan;
  };
 
}
 
#endif