Selfcal.h

Go to the documentation of this file.

#ifndef CARMA_SERVICES_SELFCAL_H
#define CARMA_SERVICES_SELFCAL_H

#include <complex>
#include <vector>


namespace carma {
  namespace services {

    typedef std::complex<double> Complex;


    class Selfcal {

    public:

      Selfcal();
      

      virtual ~Selfcal();

      void zero(void);

      void setSourceName(std::string& sourceName);

      void setReferenceAntenna(int refAnt = 0);

      void setMaxIter(int maxIter = 100);

      void setMaxAnt(int maxAnt = 0);

      void setEps(double epsi1 = 1.0e-8, double epsi2 = 1.0e-4);

      void setDebug(int debug = 0);

      void setPointSourceModel(double flux);

      void setPlanetDiskModel(double flux, double bmaj=0, double bmin=0, double bpa=0);

      void setVis(int ant1, int ant2, const Complex& vis, double weight=1);
      
      std::vector<Complex> getVis(bool useAmp = true);

      std::vector<Complex> getVisErrors(void);

      double getRMSPhase(void) const {
        return RMSPhase_;
      }

      double getRMSAmp(void) const {
        return RMSAmp_;
      }

      double getIter(void) const {
        return Niter_;
      }

      double getRefAnt(void) const {
        return refAnt_;
      }

      double getMaxAnt(void) const {
        return maxAnt_;
      }

    private:

      /*
       * Vis: a convenient container to keep all the baseline based visibilities
       *      together
       */

      typedef struct {
          Complex v;  // data
          Complex m;  // model
          double w;   // weight, typically contains 1/sigma^2, systemp, inttime
          int a1;     // a number 0...Nants-1  !!!
          int a2;     // a number 0...Nants-1 (but not equal to ant1)
          Complex sumvm;    // derived quantities, used internally
          Complex sumvmc;   // derived quantities, used internally 
          double sumvv;     // derived quantities, used internally 
      } Vis;

      void visset(Vis &data, const Complex &v, const Complex &m, double w, int a1, int a2);
      int guess_nants(int Nbaselines);
      std::vector<Complex> phasol(const std::vector<Vis> &data);
      std::vector<Complex> amphasol(const std::vector<Vis> &data);
      void computeRMS(const std::vector<Complex> &gains);

      /*
       *   Control parameters for selfcal..
       */

      double epsi1_;
      double epsi2_;
      int  maxIter_;
      std::string sourceName_;
      int debug_;
      double flux_;

      bool autoRef_;               // automatically find reference antenna
      int  refAnt_;                // reference antenna 

      /*
       * index for fast antenna lookup 
       *
       */

      bool autoAnt_;                // if true, automatically determine maxAnt_
      int  maxAnt_;                 // the maximum ant number (1..) used in the input 
      std::vector<int> antIndex_;   // index array into 0s or filled antenna number (Nant)


      /*
       * the visibility Data
       */
      std::vector<Vis> data_; 

      /*
       * Computed, and cashed until needed via the getXXX() routines
       */

      std::vector<Complex> Verrors_;
      double RMSPhase_;
      double RMSAmp_;
      int    Niter_;
      bool   solutionFailed_;
      
    }; // end class Selfcal

  } // end namespace services
} // end namespace carma


#endif