source: branches/plotter2/src/STSideBandSep.h@ 3040

// C++ Interface: STSideBandSep
//
// Description:
//    A class to invoke sideband separation of Scantable
//
// Author: Kanako Sugimoto <kana.sugi@nao.ac.jp>, (C) 2012
//
// Copyright: See COPYING file that comes with this distribution
//
//
#ifndef ASAPSIDEBANDSEP_H
#define ASAPSIDEBANDSEP_H

// STL
#include <iostream>
#include <string>
#include <vector>
// casacore
#include <casa/aips.h>
#include <casa/Utilities/CountedPtr.h>
#include <measures/Measures/MDirection.h>
#include <coordinates/Coordinates/DirectionCoordinate.h>
#include <coordinates/Coordinates/SpectralCoordinate.h>
#include <scimath/Mathematics/FFTServer.h>
// asap
#include "ScantableWrapper.h"
#include "Scantable.h"

using namespace std;
using namespace casa;

namespace asap {

class STSideBandSep {
public:
  /**
   * constructors and a destructor
   **/
  STSideBandSep() { throw( AipsError("No data set to process") ); };
  explicit STSideBandSep(const vector<string> &names);
  explicit STSideBandSep(const vector<ScantableWrapper> &tables);
  virtual ~STSideBandSep();

  ///////////// temp functions //////////////////////
  //void cpprfft(std::vector<float> invec);
  //////////////////////////////////////////////////

  /**
   * Separate side bands
   **/
  void separate(string outname);

  /**
   * Set IFNO and frequency tolerance to select data to process
   **/
  void setFrequency(const unsigned int ifno, const string freqtol,
                    const string frame="");

  /**
   * Set direction tolerance to group spectra.
   * The spectra within this range will be averaged before procesing.
   **/
  void setDirTolerance(const vector<string> dirtol);

  /**
   * Set the number of channels shifted in image side band 
   * of each of scantable.
   **/
  void setShift(const vector<double> &shift);

  /**
   * Set rejection limit of solution.
   **/
  void setThreshold(const double limit);

  /**
   * Resolve both image and signal sideband when true is set.
   **/
  void solveBoth(const bool flag) { doboth_ = flag; };

  /**
   * Obtain spectra by subtracting the solution of the other sideband.
   **/
  void solvefromOther(const bool flag) { otherside_ = flag; };

  /**
   * Set scantable to fill frequencies of image sideband (temporal)
   **/
  void setImageTable(const ScantableWrapper &s);
  void setScanTb0(const ScantableWrapper &s);

  /**
   * Set additional information to fill frequencies of image sideband
   **/
  void setLO1(const string lo1, const string frame="TOPO",
              const double reftime=-1, string refdir="");
  void setLO1Root(const string name);

private:
  /** Initialize member variables **/
  void init();
  void initshift();

  /** Return if the path exists (optionally, check file type) **/
  Bool checkFile(const string name, string type="");

  /** **/
  unsigned int setupShift();
  bool getFreqInfo(const CountedPtr<Scantable> &stab, const unsigned int &ifno,
                   double &freq0, double &incr, unsigned int &nchan);

  /** Grid scantable **/
  ScantableWrapper gridTable();
  void mapExtent(vector< CountedPtr<Scantable> > &tablist,
                 Double &xmin, Double &xmax,
                 Double &ymin, Double &ymax);

  /**
   * Actual calculation of frequencies of image sideband
   **/
  void solveImageFrequency();

  /** 
   * Get LO1 frequency to solve the frequencies of image side band
   **/
  bool getLo1FromAsdm(const string asdmname,
                      const double refval, const double refpix,
                      const double increment, const int nChan);
  bool getLo1FromAsisTab(const string msname,
                         const double refval, const double refpix,
                         const double increment, const int nChan);
  bool getLo1FromScanTab(casa::CountedPtr< Scantable > &scantab,
                         const double refval, const double refpix,
                         const double increment, const int nChan);
  bool getSpectraToSolve(const int polId, const int beamId,
                         const double dirX, const double dirY,
                         Matrix<float> &specmat, vector<uInt> &tabIdvec);

  vector<float> solve(const Matrix<float> &specmat,
                      const vector<uInt> &tabIdvec,
                      const bool signal = true);

  void shiftSpectrum(const Vector<float> &invec, double shift,
                     Vector<float> &outvec);

  void deconvolve(Matrix<float> &specmat, const vector<double> shiftvec,
                  const double threshold, Matrix<float> &outmat);

  void aggregateMat(Matrix<float> &inmat, vector<float> &outvec);

  void subtractFromOther(const Matrix<float> &shiftmat,
                         const vector<float> &invec,
                         const vector<double> &shift,
                         vector<float> &outvec);



  /** Member variables **/
  // input tables
  vector<string> infileList_;
  vector< CountedPtr<Scantable> > intabList_;
  unsigned int ntable_;
  // frequency and direction setup to select data.
  int sigIfno_;
  Quantum<Double> ftol_;
  MFrequency::Types solFrame_;
  vector<double> sigShift_, imgShift_;
  unsigned int nshift_, nchan_;
  vector< CountedPtr<Scantable> > tableList_;
  Double xtol_, ytol_;
  // solution parameters
  bool otherside_, doboth_;
  double rejlimit_;
  // LO1
  double lo1Freq_; // in Hz
  MFrequency::Types loFrame_;
  double loTime_;
  string loDir_;
  string asdmName_, asisName_;

  //CountedPtr<Scantable> imgTab_p, sigTab_p;
  CountedPtr<Scantable> imgTab_p, sigTab_p;
  Table::TableType tp_;
  FFTServer<Float, Complex> fftsf, fftsi;
  // TEMPORAL member
  CountedPtr<Scantable> st0_;

}; // class

} // namespace

#endif