SideBandSeparator.h

Go to the documentation of this file.

/*
 * SideBandSeparator.h
 *
 *  Created on: 2017/07/19
 *      Author: kana
 */

#ifndef SIDEBANDSEPARATOR_H_
#define SIDEBANDSEPARATOR_H_
// STL
#include <iostream>
#include <string>
#include <vector>
// casacore
#include <casacore/casa/aips.h>
#include <casacore/casa/Arrays/Vector.h>
#include <casacore/casa/Arrays/Matrix.h>
#include <casacore/casa/Quanta/Quantum.h>

#include <casacore/coordinates/Coordinates/CoordinateSystem.h>
#include <casacore/coordinates/Coordinates/DirectionCoordinate.h>
#include <casacore/coordinates/Coordinates/SpectralCoordinate.h>
#include <casacore/scimath/Mathematics/FFTServer.h>

// casa
#include <imageanalysis/ImageTypedefs.h>

namespace casa { //# NAMESPACE CASA - BEGIN

class SideBandSeparatorBase {
public:

          SideBandSeparatorBase(const std::vector<std::string>& inputname);
          virtual ~SideBandSeparatorBase();

          void setShift(const std::vector<double> &shift, const bool signal = true);

          void setThreshold(const double limit);

          void solveBoth(const bool flag) { doboth_ = flag; };

          void solvefromOther(const bool flag) { otherside_ = flag; };

          virtual void separate(const std::string& outfile, const bool overwrite) = 0;

protected:
          void init();
          void initshift();

          void setInput(const std::vector<std::string>& inputname);

          casacore::Bool checkFile(const std::string name, std::string type="");

          casacore::Vector<float> solve(const casacore::Matrix<float> &specMat,
                              const std::vector<casacore::uInt> &inIdvec,
                              const bool signal = true);

          casacore::Vector<bool> collapseMask(const casacore::Matrix<bool> &flagMat,
                                    const std::vector<casacore::uInt> &inIdvec,
                                    const bool signal = true);
          void shiftSpectrum(const casacore::Vector<float> &invec, double shift,
                             casacore::Vector<float> &outvec);

          void shiftFlag(const casacore::Vector<bool> &invec, double shift,
                             casacore::Vector<bool> &outvec);

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

          void aggregateMat(const casacore::Matrix<float> &inmat, std::vector<float> &outvec);

          void subtractFromOther(const casacore::Matrix<float> &shiftmat,
                                 const std::vector<float> &invec,
                                 const std::vector<double> &shift,
                                 std::vector<float> &outvec);
          size_t setupShift();

          /*
           * Interpolate masked spectrum channels
           * In-place interpolation is performed to elements with mask being false.
           * This function interpolates masked channels in the following rules.
           * o nearest interpolation for edge channels
           * o linear interpolation for intermediate masked ranges
           *
           * @param[inout] spectrum an 1-D array to be interpolated (in-place).
           * the number of elements should be equal to that of @a mask.
           * @param[in] mask an 1-D mask array. the elements in spectrum is valid
           * when corresponding elements in mask is true.
           * the number of elements should be equal to that of @a spectrum.
           *
           * the function returns false if no valid channel (mask is all false)
           */
          bool interpolateMaskedChannels(casacore::Array<float> spectrum,
                          const casacore::Array<bool> maskp);

          // name of images
          std::vector<std::string> inputNames_;
          // frequency and direction setup to select data.
          std::vector<double> sigShift_, imgShift_;
          unsigned int nshift_, nchan_;
          // solution parameters
          bool otherside_, doboth_;
          double rejlimit_;

          casacore::FFTServer<casacore::Float, casacore::Complex> fftsf, fftsi;


}; // SideBandSeparatorBase

class SideBandSeparatorII : public SideBandSeparatorBase {
public:
          SideBandSeparatorII(const std::vector<std::string>& imagename);
          virtual ~SideBandSeparatorII(){};

          virtual void separate(const std::string& outfile, const bool overwrite);

          void setImageBandFrequency(const double refpix, const casacore::Quantity refval);

          //protected:
private:
          void initLocal();
          void checkImage();

          bool getImageCoordinate(const string& imagename, casacore::CoordinateSystem &csys, casacore::IPosition &npix);
          bool compareImageAxes(const string& imagename, const casacore::CoordinateSystem &refcsys, const casacore::IPosition &refnpix);
          bool getSpectraToSolve(const std::vector<casa::SPIIF> &images, const casacore::Slicer &slicer,
                          casacore::Matrix<float>& specMat, casacore::Matrix<bool>& maskMat, std::vector<casacore::uInt>& imgIdvec);
          double refFreqPix_, refFreqHz_;

};


} //# NAMESPACE CASA - END
#endif /* SIDEBANDSEPARATOR_H_ */