NewMSSimulator.h

Go to the documentation of this file.

// # NewMSSimulator.h: this defines the MeasurementSet Simulator
// # Copyright (C) 1995-2009
// # 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: casa-feedback@nrao.edu.
// #        Postal address: AIPS++ Project Office
// #                        National Radio Astronomy Observatory
// #                        520 Edgemont Road
// #                        Charlottesville, VA 22903-2475 USA
 
#ifndef MS_NEWMSSIMULATOR_H
#define MS_NEWMSSIMULATOR_H
 
// # Includes
#include <memory>
#include <casacore/casa/aips.h>
#include <casacore/casa/BasicSL/String.h>
#include <casacore/casa/Arrays/Vector.h>
#include <casacore/casa/Arrays/Matrix.h>
#include <casacore/casa/Arrays/Cube.h>
#include <casacore/casa/BasicSL/Complex.h>
#include <casacore/casa/Quanta/Quantum.h>
#include <casacore/measures/Measures/MPosition.h>
#include <casacore/measures/Measures/MEpoch.h>
#include <casacore/measures/Measures/MFrequency.h>
#include <casacore/measures/Measures/MDirection.h>
 
#include <casacore/tables/DataMan/TiledDataStManAccessor.h>
 
namespace casacore {  // # NAMESPACE CASACORE - BEGIN
 
// # Forward Declarations
class MeasurementSet;
 
// <category lib=aips module="ModuleName">
// <summary> Create an empty MeasurementSet from observation and telescope descriptions. </summary>
// <reviewed reviewer="" date="" tests="">
//
// <prerequisite>
// # Classes you should understand before using this one.
//  <li> MeasurementSet
// </prerequisite>
//
// <etymology>
// MS is from MeasurementSet, Simulator refers to the generation of
// 'fake' data from a set of parameters for instrument and sources.
// </etymology>
//
// <synopsis>
// This class creates a MeasurementSet from a set of parameters for instrument
// and sources. It does not simulate the data, only the coordinates of a
// measurement. The application "simulator" uses this class to create a true
// simulated MS with perfect or corrupted data.
// </synopsis>
//
// <motivation>
// To test calibration and imaging programs it is necessary to have flawless
// data and data with errors that are known exactly. This class generates
// empty MeasurementSets (only coordinates filled in) that can be filled
// with predicted data.
// </motivation>
//
// <todo asof="$DATE:$">
// # A List of bugs, limitations, extensions or planned refinements.
// <li>     The amount of information to be specified by the user
//          could be much larger. For the moment it has been restricted to
//          what is needed for testing the synthesis imaging code. Already
//          it is possible to create MeasurementSets that cannot be processed
//          yet.
// </todo>
 
class NewMSSimulator {
 public:
  // Constructor from name only
  NewMSSimulator(const String&);
 
  // Constructor from existing MS
  NewMSSimulator(MeasurementSet&);
 
  // Copy constructor - for completeness only
  NewMSSimulator(const NewMSSimulator& mss);
 
  // # Destructor
  ~NewMSSimulator();
 
  // # Operators
  //  Assignment
  NewMSSimulator& operator=(const NewMSSimulator&);
 
  // Set maximum amount of data (bytes) to be written into any one
  // scratch column hypercube
  void setMaxData(const Double maxData = 2e9) { maxData_p = maxData; }
 
  // set the antenna and array data. These are written immediately to the
  // existing MS. The same model is used for the other init infor.
  void initAnt(const String& telname, const Vector<Double>& x, const Vector<Double>& y,
               const Vector<Double>& z, const Vector<Double>& dishDiameter,
               const Vector<Double>& offset, const Vector<String>& mount,
               const Vector<String>& name, const Vector<String>& padname, const String& coordsystem,
               const MPosition& mRefLocation);
  // get the info back
  bool getAnt(String& telescope, Int& nAnt, Matrix<Double>* antXYZ, Vector<Double>& antDiam,
              Vector<Double>& offset, Vector<String>& mount, Vector<String>& name,
              Vector<String>& padname, String& coordsystem, MPosition& mRefLocation);
 
  // set the observed fields
  void initFields(const String& sourceName, const MDirection& sourceDirection,
                  const String& calCode);
 
  bool getFields(Int& nField, Vector<String>& sourceName, Vector<MDirection>& sourceDirection,
                 Vector<String>& calCode);
 
  // set the Feeds;  brain dead version
  void initFeeds(const String& mode);
 
  bool getFeedMode(String& mode);
 
  // set the Feeds;  Smart version
  void initFeeds(const String& mode, const Vector<Double>& x, const Vector<Double>& y,
                 const Vector<String>& pol);
 
  // set the spectral windows information
  void initSpWindows(const String& spWindowName, const Int& nChan, const Quantity& startFreq,
                     const Quantity& freqInc, const Quantity& freqRes,
                     const MFrequency::Types& freqType, const String& stokesString);
 
  bool getSpWindows(Int& nSpw, Vector<String>& spWindowName, Vector<Int>& nChan,
                    Vector<Quantity>& startFreq, Vector<Quantity>& freqInc,
                    Vector<String>& stokesString);
 
  void setFractionBlockageLimit(const Double fraclimit) { fractionBlockageLimit_p = fraclimit; }
 
  void setElevationLimit(const Quantity& ellimit) { elevationLimit_p = ellimit; }
 
  void setAutoCorrelationWt(const Float autocorrwt) { autoCorrelationWt_p = autocorrwt; }
 
  void settimes(const Quantity& qIntegrationTime, const Bool useHourAngles, const MEpoch& mRefTime);
 
  void observe(const String& sourceName, const String& spWindowName, const Quantity& qStartTime,
               const Quantity& qStopTime, const Bool add_observation = True,
               // # from int ASDM2MSFiller::addUniqueState(
               // # defaults for ALMA as known on 20100831
               const Bool state_sig = True, const Bool state_ref = True,
               const double& state_cal = 0., const double& state_load = 0.,
               const unsigned int state_sub_scan = 1,
               const String& state_obs_mode = "OBSERVE_TARGET.ON_SOURCE",
               const String& observername = "CASA simulator",
               const String& projectname = "CASA simulation");
 
  void observe(const Vector<String>& sourceNames, const String& spWindowName,
               const Vector<Quantity>& qStartTimes, const Vector<Quantity>& qStopTimes,
               const Vector<MDirection>& directions, const Bool add_observation = True,
               // # from int ASDM2MSFiller::addUniqueState(
               // # defaults for ALMA as known on 20100831
               const Bool state_sig = True, const Bool state_ref = True,
               const double& state_cal = 0., const double& state_load = 0.,
               const unsigned int state_sub_scan = 1,
               const String& state_obs_mode = "OBSERVE_TARGET.ON_SOURCE",
               const String& observername = "CASA simulator",
               const String& projectname = "CASA simulation");
 
  std::shared_ptr<MeasurementSet> getMs() const;
 
 private:
  // Prevent use of default constructor
  NewMSSimulator() {}
 
  // # Data Members
  Double fractionBlockageLimit_p;
  Quantity elevationLimit_p;
  Float autoCorrelationWt_p;
  String telescope_p;
  Quantity qIntegrationTime_p;
  Bool useHourAngle_p;
  Bool hourAngleDefined_p;
  MEpoch mRefTime_p;
  Double t_offset_p;
  Double dataWritten_p;
  Int hyperCubeID_p;
  Bool hasHyperCubes_p;
  Int lastSpWID_p;
  Int lastNchan_p;
 
  std::shared_ptr<MeasurementSet> ms_p;
 
  TiledDataStManAccessor dataAcc_p, scratchDataAcc_p, sigmaAcc_p, flagAcc_p;
 
  Double maxData_p;
 
  void local2global(Vector<Double>& xReturned, Vector<Double>& yReturned, Vector<Double>& zReturned,
                    const MPosition& mRefLocation, const Vector<Double>& xIn,
                    const Vector<Double>& yIn, const Vector<Double>& zIn);
 
  void longlat2global(Vector<Double>& xReturned, Vector<Double>& yReturned,
                      Vector<Double>& zReturned, const MPosition& mRefLocation,
                      const Vector<Double>& xIn, const Vector<Double>& yIn,
                      const Vector<Double>& zIn);
 
  // Returns the fractional blockage of one antenna by another
  // We will want to put this somewhere else eventually, but I don't yet know where!
  // Till then.
  // fraction1: fraction of antenna 1 that is blocked by 2
  // fraction2: fraction of antenna 2 that is blocked by 1
  // hint: at least one of the two will be 0.0
  void blockage(Double& fraction1, Double& fraction2,
                const Vector<Double>& uvw,  // uvw in same units as diam!
                const Double diam1, const Double diam2);
 
  String formatDirection(const MDirection&);
  String formatTime(const Double);
 
  void addHyperCubes(const Int id, const Int nBase, const Int nChan, const Int nCorr);
 
  void defaults();
 
  Bool calcAntUVW(MEpoch& epoch, MDirection& refdir, Matrix<Double>& uvwAnt);
};
 
}  // namespace casacore
 
#endif