TimeVarVisJones.h

Classes

TimeVarVisJones -- Model time-variable multiplicative errors for the VisEquation (full description)
PJones -- Model parallactic angle corrections for the VisEquation (full description)
CJones -- Model configuration matrix corrections for the VisEquation (full description)

class TimeVarVisJones : public VisJones

Interface

Public Members
TimeVarVisJones()
TimeVarVisJones(VisSet& vs)
TimeVarVisJones(const TimeVarVisJones& other)
virtual ~TimeVarVisJones()
virtual void makeLocalVisSet()
virtual void setInterpolation(const Record& interpolation)
virtual Type type()=0
virtual Bool freqDep()
virtual Bool isSolved()
virtual Bool isApplied()
virtual Double interval()
virtual Double preavg()
virtual VisBuffer& apply(VisBuffer& vb)
virtual VisBuffer& applyInv(VisBuffer& vb)
virtual VisBuffer & applyGradient(VisBuffer & vb, const Vector<int> & v, Int a1, Int a2, Int pos)
virtual void addGradients(const VisBuffer& vb, Int row, const Antenna& a, const Vector<Float>& sumwt, const Vector<Float>& chisq, const Vector<mjJones2>& c, const Vector<mjJones2F>& f)
virtual Bool solve(class VisEquation &)
virtual void store(const String& file, const Bool& append)
virtual void query()
Protected Members
virtual void load(const String& file, const String& select, const String& type)
void initialize(VisSet& vs)
void initializeCache()
void initGainCache()
void deleteCache()
void initMetaCache()
void fillMetaCache()
void deleteMetaCache()
void initSlotCache()
void deleteSlotCache()
void countSlots()
void setSolved(const Bool& flag)
void setApplied(const Bool& flag)
virtual void getAntGain(Matrix<mjJones2>& ag, Vector<Bool>& agOK, const Vector& vb, const Double& time) = 0
Bool inSlot(Int& slot, const Double& time)
Int findSlot(const Double& time)
virtual void checkCache(const VisBuffer& vb, const Int& spw, const Double& time)
virtual void updateCache(const VisBuffer& vb, const Int& spw, const Double& time)
void invalidateCache()
void invalidateCache(Int spectralWindow)
void validateCache(Int spectralWindow)
Bool cacheValid(Int spectralWindow)
virtual Bool polznSwitch(const VisBuffer& vb)
virtual void polznMap(CStokesVector& vis)
virtual void polznUnmap(CStokesVector& vis)
LogSink& logSink()

Description

Prerequisite

Etymology

TimeVarVisJones describes an interface for time variable but not solvable multiplicative errors to be used in the VisEquation.

Synopsis

See VisEquation for definition of the Visibility Measurement Equation.

TimeVarVisJones performs caching of values to minimize computation.

Values may be saved to a table.

Example

      // Read the VisSet from disk
      VisSet vs("3c84.MS");

      VisEquation ve(vs);

      // Make an VisJones
      PJones pj(vs);

      ve.setVisJones(pj);

      // Correct the visset
      ve.correct();

Motivation

The properties of an multiplicative component must be described for the VisEquation.

To Do

Member Description

TimeVarVisJones()

TimeVarVisJones(VisSet& vs)

From VisSet

TimeVarVisJones(const TimeVarVisJones& other)

Copy

virtual ~TimeVarVisJones()

Assignment virtual TimeVarVisJones& operator=(const TimeVarVisJones& other);

Destructor

virtual void makeLocalVisSet()

Make local VisSet

virtual void setInterpolation(const Record& interpolation)

Setup apply context

virtual Type type()=0

Return the type of this Jones matrix (actual type of derived class).

virtual Bool freqDep()

Frequency-dependent ?

virtual Bool isSolved()

Is this Jones matrix to be solved for, applied or both ?

virtual Bool isApplied()

virtual Double interval()

Return the interval over which this Jones matrix is constant

virtual Double preavg()

Return the pre-averaging interval (here equal to the interval).

virtual VisBuffer& apply(VisBuffer& vb)

Apply Jones matrix

virtual VisBuffer& applyInv(VisBuffer& vb)

Apply inverse of Jones matrix

virtual VisBuffer & applyGradient(VisBuffer & vb, const Vector<int> & v, Int a1, Int a2, Int pos)

virtual void addGradients(const VisBuffer& vb, Int row, const Antenna& a, const Vector<Float>& sumwt, const Vector<Float>& chisq, const Vector<mjJones2>& c, const Vector<mjJones2F>& f)

virtual Bool solve(class VisEquation &)

virtual void store(const String& file, const Bool& append)

Store the time-variable gains as a table. Derived classes may need to redefine this if they do not use antGain_.

virtual void query()

print out internals

virtual void load(const String& file, const String& select, const String& type)

Retrieve the time-variable gains from a table.

void initialize(VisSet& vs)

void initializeCache()

void initGainCache()

void deleteCache()

void initMetaCache()

void fillMetaCache()

void deleteMetaCache()

void initSlotCache()

void deleteSlotCache()

void countSlots()

count up slots

void setSolved(const Bool& flag)

Mark this Jones matrix as being solved for

void setApplied(const Bool& flag)

Mark this Jones matrix as being applied

virtual void getAntGain(Matrix<mjJones2>& ag, Vector<Bool>& agOK, const Vector& vb, const Double& time) = 0

Calculate gains ab initio. To be defined in derived class

Bool inSlot(Int& slot, const Double& time)

Is the time in the specified slot. slot must be in range

Int findSlot(const Double& time)

Find the relevant slot. Throw an exception if not found.

virtual void checkCache(const VisBuffer& vb, const Int& spw, const Double& time)

check the cache : if necessary, assign new slot, update Gains and Cache

virtual void updateCache(const VisBuffer& vb, const Int& spw, const Double& time)

update the Cache

void invalidateCache()

(in)validate cache

void invalidateCache(Int spectralWindow)

void validateCache(Int spectralWindow)

Bool cacheValid(Int spectralWindow)

virtual Bool polznSwitch(const VisBuffer& vb)

Return true if polarization re-sequencing required

virtual void polznMap(CStokesVector& vis)

Re-sequence to (XX,XY,YX,YY) or (RR,RL,LR,LL)

virtual void polznUnmap(CStokesVector& vis)

Re-sequence to (XX,YY,XY,YX) or (RR,LL,RL,LR)

LogSink& logSink()


class PJones : public TimeVarVisJones

Interface

Public Members
PJones(VisSet& vs)
PJones(VisSet& vs, Double interval, Double deltat=1.0)
~PJones()
virtual Type type()
virtual void store(const String& file, const Bool& append)
Private Members
virtual void getAntGain(Matrix<mjJones2>& ag, Vector<Bool>& agOK, const Vector& vb, const Double& time)

Description

******************************************************************** ******************************************************************** ********************************************************************

Specialized non-solvable types: ******************************

Prerequisite

Etymology

PJones describes an interface for parallactic angle corrections to be used in the VisEquation.

Synopsis

See VisEquation for definition of the Visibility Measurement Equation.

Motivation

To optimize correction for parallactic angle in the VisEquation.

To Do

Member Description

PJones(VisSet& vs)

PJones(VisSet& vs, Double interval, Double deltat=1.0)

~PJones()

virtual Type type()

virtual void store(const String& file, const Bool& append)

virtual void getAntGain(Matrix<mjJones2>& ag, Vector<Bool>& agOK, const Vector& vb, const Double& time)

Calculate gains ab initio using the information in the iterator

class CJones : public TimeVarVisJones

Interface

Public Members
CJones(VisSet& vs)
~CJones()
virtual Type type()
virtual void store(const String& file, const Bool& append)
Private Members
virtual void getAntGain(Matrix<mjJones2>& ag, Vector<Bool>& agOK, const Vector& vb, const Double& time)

Description

******************************************************************** ********************************************************************

Prerequisite

Etymology

CJones describes an interface for the configuration matrix to be used in the VisEquation.

Synopsis

See VisEquation for definition of the Visibility Measurement Equation.

Motivation

To optimize correction for configuration matrix in the VisEquation.

To Do

Member Description

CJones(VisSet& vs)

~CJones()

virtual Type type()

virtual void store(const String& file, const Bool& append)

virtual void getAntGain(Matrix<mjJones2>& ag, Vector<Bool>& agOK, const Vector& vb, const Double& time)

Calculate gains ab initio using the information in the iterator