SynthesisImager.h

Go to the documentation of this file.

//# SynthesisImager.h: Imager functionality sits here; 
//# Copyright (C) 2012-2013
//# Associated Universities, Inc. Washington DC, USA.
//#
//# This library is free software; you can redistribute it and/or modify it
//# under the terms of the GNU Library General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or (at your
//# option) any later version.
//#
//# This library is distributed in the hope that it will be useful, but WITHOUT
//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
//# License for more details.
//#
//# You should have received a copy of the GNU Library General Public License
//# along with this library; if not, write to the Free Software Foundation,
//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
//#
//# Correspondence concerning AIPS++ should be addressed as follows:
//#        Internet email: aips2-request@nrao.edu.
//#        Postal address: AIPS++ Project Office
//#                        National Radio Astronomy Observatory
//#                        520 Edgemont Road
//#
//# $Id$

#ifndef SYNTHESIS_SYNTHESISIMAGER_H
#define SYNTHESIS_SYNTHESISIMAGER_H

#include <casa/aips.h>
#include <casa/OS/Timer.h>
#include <casa/Containers/Record.h>
#include <ms/MeasurementSets/MeasurementSet.h>
#include <casa/Arrays/IPosition.h>
#include <casa/Quanta/Quantum.h>
#include <measures/Measures/MDirection.h>
#include<synthesis/ImagerObjects/SynthesisUtilMethods.h>

#include<synthesis/ImagerObjects/SIMapperCollection.h>
#include <msvis/MSVis/ViFrequencySelection.h>


#include <synthesis/TransformMachines/FTMachine.h>
#include <synthesis/TransformMachines/ATerm.h>

namespace casa { //# NAMESPACE CASA - BEGIN

// Forward declarations
class MeasurementSet;
template<class T> class ImageInterface;
 class SIIterBot;
 class VisImagingWeight;

// <summary> Class that contains functions needed for imager </summary>

class SynthesisImager 
{
 public:
  // Default constructor

  SynthesisImager();
  virtual ~SynthesisImager();

  // Copy constructor and assignment operator
  //Imager(const Imager&);
  //Imager& operator=(const Imager&);

  virtual Bool selectData(const SynthesisParamsSelect& selpars);
 

  // make all pure-inputs const
  virtual Bool selectData(const String& msname, 
                          const String& spw="*", 
                          const String& freqBeg="", 
                          const String& freqEnd="",
                          const MFrequency::Types freqFrame=MFrequency::LSRK, 
                          const String& field="*", 
                          const String& antenna="",  
                          const String& timestr="", 
                          const String& scan="", 
                          const String& obs="",
                          const String& state="",
                          const String& uvdist="", 
                          const String& taql="",
                          const Bool usescratch=False, 
                          const Bool readonly=False, 
                          const Bool incrementModel=False);

  virtual Bool defineImage(SynthesisParamsImage& impars, const SynthesisParamsGrid& gridpars);

  //When having a facetted image ...call with (facets > 1)  first and  once only ..
  //Easier to keep track of the imstores that way
  virtual Bool defineImage(const String& imagename, const Int nx, const Int ny,
                           const Quantity& cellx, const Quantity& celly,
                           const String& stokes,
                           const MDirection& phaseCenter, 
                           const Int nchan,
                           const Quantity& freqStart,
                           const Quantity& freqStep, 
                           const Vector<Quantity>& restFreq,
                           const Int facets=1,
                           //                      const Int chanchunks=1,
                           const String ftmachine="gridft",
                           const Int nTaylorTerms=1,
                           const Quantity& refFreq = Quantity(0,"Hz"),
                           const Projection& projection=Projection::SIN,
                           const Quantity& distance=Quantity(0,"m"),
                           const MFrequency::Types& freqFrame=MFrequency::LSRK,
                           const Bool trackSource=False, 
                           const MDirection& trackDir=MDirection(Quantity(0.0, "deg"), Quantity(90.0, "deg")), 
                           const Bool overwrite=False,
                           const Float padding=1.0, 
                           const Bool useAutocorr=False, 
                           const bool useDoublePrec=True, 
                           const Int wprojplanes=1, 
                           const String convFunc="SF", 
                           //                      const String vptable="",
                           const String startmodel="",
                           // The extra params for WB-AWP
                           const Bool aTermOn    = True,
                           const Bool psTermOn   = True,
                           const Bool mTermOn    = False,
                           const Bool wbAWP      = True,
                           const String cfCache  = "",
                           const Bool doPointing = False,
                           const Bool doPBCorr   = True,
                           const Bool conjBeams  = True,
                           const Float computePAStep=360.0,
                           const Float rotatePAStep=5.0
                           );
  //Define image via a predefine SIImageStore object
  virtual Bool defineImage(CountedPtr<SIImageStore> imstor, 
                           const String& ftmachine);

  Record getcsys() {return itsCsysRec;};
  Int updateNchan() {return itsNchan;};

  //Function to tune the data selection to intersect with image definition chosen
  //This is to optimize the data selection so that unnecessary data is not parsed despite the user
  // deciding to select so.
  // defineimage has to be run first (and thus selectData prior to that) otherwise an exception is thrown
  virtual Vector<SynthesisParamsSelect> tuneSelectData();

  //Defining componentlist to use while degriding
  //This should be called once...if multiple lists are used..they can be merged in one
  //if sdgrid=True then image plane degridding is done

  virtual void setComponentList(const ComponentList& cl, 
                                Bool sdgrid=False);
  virtual Bool weight(const String& type="natural", 
              const String& rmode="norm",
              const Quantity& noise=Quantity(0.0, "Jy"), 
              const Double robust=0.0,
              const Quantity& fieldofview=Quantity(0.0, "arcsec"),
              const Int npixels=0, 
              const Bool multiField=False,
              const String& filtertype=String("Gaussian"),
              const Quantity& filterbmaj=Quantity(0.0,"deg"),
              const Quantity& filterbmin=Quantity(0.0,"deg"),
              const Quantity& filterbpa=Quantity(0.0,"deg")  );

  Bool getWeightDensity();
  virtual Bool setWeightDensity();

  //the following get rid of the mappers in this object
  void resetMappers();

  CountedPtr<SIImageStore> imageStore(const Int id=0);

  //Record getMajorCycleControls();
  void executeMajorCycle(Record& controls);

  // make the psf images  i.e grid weight rather than data
  void makePSF();


  virtual Bool makePB();
  
  virtual void predictModel();
  //  void makeImage();
  /* Access method to the Loop Controller held in this class */
  //SIIterBot& getLoopControls();

  virtual void dryGridding(const Vector<String>& cfList);
  virtual void fillCFCache(const Vector<String>& cfList, const String& ftmName, const String& cfcPath,
                           const Bool& psTermOn, const Bool& aTermOn); 
  virtual void reloadCFCache();

  static String doubleToString(const Double& df); 
 
protected:
 

  // Choose between different types of FTMs
  void createFTMachine(CountedPtr<FTMachine>& theFT, 
                       CountedPtr<FTMachine>& theIFT,  
                       const String& ftname,
                       const uInt nTaylorTerms=1, 
                       const String mType="default",
                       const Int facets=1,
                       //------------------------------
                       const Int wprojplane=1,
                       const Float padding=1.0,
                       const Bool useAutocorr=False,
                       const Bool useDoublePrec=True,
                       const String gridFunction=String("SF"),
                       //------------------------------
                       const Bool aTermOn    = True,
                       const Bool psTermOn   = True,
                       const Bool mTermOn    = False,
                       const Bool wbAWP      = True,
                       const String cfCache  = "",
                       const Bool doPointing = False,
                       const Bool doPBCorr   = True,
                       const Bool conjBeams  = True,
                       const Float computePAStep   = 360.0,
                       const Float rotatePAStep    = 5.0,
                       const String interpolation = String("linear"),
                       const Bool freqFrameValid = True,
                       const Int cache=1000000000,
                       const Int tile=16,
                       const String stokes="I",
                       const String imageNamePrefix="");

  void createMosFTMachine(CountedPtr<FTMachine>& theFT, CountedPtr<FTMachine>&  theIFT, const Float  padding, const Bool useAutoCorr, const Bool useDoublePrec, const Float rotatePAStep, const String Stokes="I");

  // Choose between different types of ImageStore types (single term, multiterm, faceted)
  CountedPtr<SIImageStore> createIMStore(String imageName, 
                                         CoordinateSystem& cSys,
                                         IPosition imShape, 
                                         const Bool overwrite,
                                         ROMSColumns& msc, 
                                         String mappertype="default", 
                                         uInt ntaylorterms=1,
                                         Quantity distance=Quantity(0.0, "m"),
                                         uInt facets=1,
                                         Bool useweightimage=False,
                                         Vector<String> startmodel=Vector<String>(0));
  
  // Choose between different types of Mappers (single term, multiterm, imagemosaic, faceted)
  CountedPtr<SIMapper> createSIMapper(String mappertype,  
                                          CountedPtr<SIImageStore> imagestore, 
                                      CountedPtr<FTMachine> ftmachine,
                                      CountedPtr<FTMachine> iftmachine,
                                      uInt ntaylorterms=1);

  Block<CountedPtr<SIImageStore> > createFacetImageStoreList(
                                                             CountedPtr<SIImageStore> imagestore,
                                                             Int facets);
  // void setPsfFromOneFacet();
  Block<CountedPtr<SIImageStore> > createChanChunkImageStoreList(
                                                             CountedPtr<SIImageStore> imagestore,
                                                             Int chanchunks);

  Bool toUseWeightImage(CountedPtr<FTMachine>& ftm, String mappertype);

  virtual void createVisSet(const Bool writeaccess=False);
  
  void createAWPFTMachine(CountedPtr<FTMachine>& theFT, CountedPtr<FTMachine>& theIFT, 
                          const String& ftmName,
                          const Int facets,          
                          //----------------------------
                          const Int wprojPlane,     
                          const Float padding,      
                          const Bool useAutocorr,   
                          const Bool useDoublePrec, 
                          const String gridFunction,
                          //---------------------------
                          const Bool aTermOn,      
                          const Bool psTermOn,     
                          const Bool mTermOn,      
                          const Bool wbAWP,        
                          const String cfCache,    
                          const Bool doPointing,   
                          const Bool doPBCorr,     
                          const Bool conjBeams,    
                          const Float computePAStep,
                          const Float rotatePAStep, 
                          const Int cache,          
                          const Int tile,
                          const String imageNamePrefix="");
  ATerm* createTelescopeATerm(const MeasurementSet& ms, const Bool& isATermOn);

  // Get VP record
  void getVPRecord(Record &rec, PBMath::CommonPB &kpb, String telescop);

  // Do the major cycle
  virtual void runMajorCycle(const Bool dopsf=False, const Bool savemodel=False);

  // Version of major cycle code with mappers in a loop outside vi/vb.
  virtual void runMajorCycle2(const Bool dopsf=False, const Bool savemodel=False);

  //  void appendToMapperList(String imagename, CoordinateSystem& csys, String ftmachine,
  //                      Quantity distance=Quantity(0.0, "m"), Int facets=1, const Bool overwrite=False);

  void appendToMapperList(String imagename, 
                          CoordinateSystem& csys, 
                          IPosition imshape,
                          CountedPtr<FTMachine>& ftm,
                          CountedPtr<FTMachine>& iftm,
                          Quantity distance=Quantity(0.0, "m"), 
                          Int facets=1, 
                          Int chanchunks=1,
                          const Bool overwrite=False,
                          String mappertype=String("default"),
                          Float padding=1.0,
                          uInt ntaylorterms=1,
                          Vector<String> startmodel=Vector<String>(0));

  virtual void unlockMSs();

  Bool makePBImage(const String& telescopeName, 
                   Bool useSymmetricBeam, Double diam);
  Bool makePBImage(const String telescop);
  virtual Bool makePrimaryBeam(PBMath& pbMath);


  SIMapperCollection itsMappers;
  CountedPtr<SIImageStore> unFacettedImStore_p;
  CountedPtr<SIImageStore> unChanChunkedImStore_p;

  Bool itsDataLoopPerMapper;

  CoordinateSystem itsMaxCoordSys;
  IPosition itsMaxShape;
  Record itsCsysRec;
  Int itsNchan;

  String itsVpTable; 
  Bool itsMakeVP;


  // Data Selection
  Vector<SynthesisParamsSelect> dataSel_p;
  // Image Definition
  // Imaging/Gridding

  Block<const MeasurementSet *> mss_p;
  vi::FrequencySelections fselections_p;
  CountedPtr<vi::VisibilityIterator2>  vi_p;

  // Other Options
  Bool useViVb2_p;
  Block<MeasurementSet> mss4vi_p;
  VisibilityIterator* wvi_p;
  ROVisibilityIterator* rvi_p;
  Block<Vector<Int> > blockNChan_p;
  Block<Vector<Int> > blockStart_p;
  Block<Vector<Int> > blockStep_p;
  Block<Vector<Int> > blockSpw_p;
  Matrix<Double> mssFreqSel_p;
  //the 'channel flags' to handle various channel selections in the spw parameter
  Cube<Int > chanSel_p;

  Bool writeAccess_p;
  MPosition mLocation_p;
  MDirection phaseCenter_p;
  Int facetsStore_p,chanChunksStore_p;
  VisImagingWeight imwgt_p;
  Bool imageDefined_p;
  Bool useScratch_p,readOnly_p;
  //
  //  Bool freqFrameValid_p;

  FTMachine::Type datacol_p;

  Int nMajorCycles;

};


} //# NAMESPACE CASA - END

#endif