model_image_polynomial_variable Class Reference

Defines a polynomial variable image model given an input image model. More...

#include "model/model_image_polynomial_variable.h"

Inheritance diagram for model_image_polynomial_variable:
Collaboration diagram for model_image_polynomial_variable:

Public Member Functions

 model_image_polynomial_variable (model_image &image, std::vector< int > order, double tref=0)
 Constructor. Takes a model_image object, a vector of orders, and optional reference time.
 
 model_image_polynomial_variable (model_image &image, int order, double tref=0)
 Constructor. Takes a model_image object, single order, and optional reference time.
 
virtual ~model_image_polynomial_variable ()
 Constructor. Takes a pair of model_image objects.
 
void set_reference_time (double tref)
 Access to set reference time after construction.
 
double reference_time () const
 Access to access reference time.
 
virtual size_t size () const
 A user-supplied function that returns the number of the parameters the model expects.
 
virtual std::string model_tag () const
 Return a string that contains a unique identifying tag for use with the ThemisPy plotting features.
 
virtual void generate_model (std::vector< double > parameters)
 A one-time generate function that permits model construction prior to calling the visibility_amplitude, closure_phase, etc. for each datum. Takes a vector of parameters.
 
void generate_image_model (double t)
 A MANY-time generate function to construct the underlying model_image object for each datum. Takes a vector of parameters. Note that this will be called for EVERY data point, meaning that if the underlying model is not efficient (e.g., analytical) this will be VERY slow.
 
virtual std::complex< double > visibility (datum_visibility &d, double acc)
 Returns complex visibility in Jy computed from the image given a datum_visibility_amplitude object, containing all of the accoutrements. While this provides access to the actual data value, the two could be separated if necessary. Also takes an accuracy parameter with the same units as the data, indicating the accuracy with which the model must generate a comparison value. Note that this is redefined to accomodate the possibility of using the analytical computation.
 
virtual double visibility_amplitude (datum_visibility_amplitude &d, double acc)
 Returns visibility ampitudes in Jy computed from the image given a datum_visibility_amplitude object, containing all of the accoutrements. While this provides access to the actual data value, the two could be separated if necessary. Also takes an accuracy parameter with the same units as the data, indicating the accuracy with which the model must generate a comparison value. Note that this is redefined to accomodate the possibility of using the analytical computation.
 
virtual double closure_phase (datum_closure_phase &d, double acc)
 Returns closure phase in degrees computed from the image given a datum_closure_phase object, containing all of the accoutrements. While this provides access to the actual data value, the two could be separated if necessary. Also takes an accuracy parameter with the same units as the data, indicating the accuracy with which the model must generate a comparison value. Note that this is redefined since the closure phase of Gaussian images is identically zero.
 
virtual double closure_amplitude (datum_closure_amplitude &d, double acc)
 Returns closure amplitude computed from the image given a datum_closure_phase object, containing all of the accoutrements. While this provides access to the actual data value, the two could be separated if necessary. Also takes an accuracy parameter with the same units as the data, indicating the accuracy with which the model must generate a comparison value. Note that this can be redefined in child classes.
 
- Public Member Functions inherited from model_image
virtual void generate_complex_visibilities ()
 A one-time generate function that will generate the complex visibilities and store them. This must be called after generate_model has been called.
 
void output_image (std::string fname, bool rotate=false)
 
void get_image (std::vector< std::vector< double > > &alpha, std::vector< std::vector< double > > &beta, std::vector< std::vector< double > > &I) const
 Provides direct access to the constructed image. Sets a 2D grid of angles (alpha, beta) in radians and intensities in Jy per steradian.
 
void get_visibilities (std::vector< std::vector< double > > &u, std::vector< std::vector< double > > &v, std::vector< std::vector< std::complex< double > > > &V) const
 Provides direct access to the complex visibilities. Sets a 2D grid of baselines (u,v) in lambda, and visibilites in Jy.
 
void get_visibility_amplitudes (std::vector< std::vector< double > > &u, std::vector< std::vector< double > > &v, std::vector< std::vector< double > > &V) const
 Provides direct access to the visibility amplitudes. Sets a 2D grid of baselines (u,v) in lambda, and visibilites in Jy.
 
void use_spline_interp (bool use_spline)
 Provides ability to use bicubic spline interpolator (true) instead of regular bicubic. Code defaults to false.
 
virtual void set_mpi_communicator (MPI_Comm comm)
 Defines a set of processors provided to the model for parallel computation via an MPI communicator. Only facilates code parallelization if the model computation is parallelized via MPI.
 
void write_model_tag_file (std::string tagfilename="model_image.tag") const
 Write a unique identifying tag for use with the ThemisPy plotting features. This calls the overloaded version with the outstream, which is the only function that need be rewritten in child classes.
 
virtual void write_model_tag_file (std::ofstream &tagout) const
 Write a unique identifying tag for use with the ThemisPy plotting features. For most child classes, the default implementation is suffcient. However, should that not be the case, this is the only function that need be rewritten in child classes.
 

Private Member Functions

virtual void generate_image (std::vector< double > parameters, std::vector< std::vector< double > > &I, std::vector< std::vector< double > > &alpha, std::vector< std::vector< double > > &beta)
 Note that this is not defined because there is no uniform image size/resolution specification.
 

Private Attributes

model_image_image
 
size_t _new_size
 Number of parameters total.
 
std::vector< int > _orders
 
double _tref
 
std::vector< double > _image_parameters
 

Additional Inherited Members

- Protected Attributes inherited from model_image
MPI_Comm _comm
 
bool _generated_model
 True when a model is generated with generate_model.
 
bool _generated_visibilities
 True when model visibilities have been computed.
 
bool _use_spline
 True when want to use bicubic spline interpolator.
 
double _position_angle
 Position angle of the image, assumed to be the last element of the parameter list passed to generate_model. Assumed to be in radians and defined E of N.
 
std::vector< double > _current_parameters
 Last set of parameters passed to generate_image, useful to determine if it is necessary to recompute the model. Useful, e.g., if we are varying only position angle, or if recomputing for a number of different data sets at the same set of parameters.
 
std::vector< std::vector< double > > _alpha
 2D grid of horizonal pixel locations in radians, relative to the fiducial direction of the image (i.e., unrotated by the position angle).
 
std::vector< std::vector< double > > _beta
 2D grid of vertical pixel locations in radians, relative to the fiducial direction of the image (i.e., unrotated by the position angle).
 
std::vector< std::vector< double > > _I
 2D grid of intensities at pixel locations in Jy/str.
 
- Protected Attributes inherited from model_visibility
MPI_Comm _comm
 
- Protected Attributes inherited from model_visibility_amplitude
MPI_Comm _comm
 
- Protected Attributes inherited from model_closure_phase
MPI_Comm _comm
 
- Protected Attributes inherited from model_closure_amplitude
MPI_Comm _comm
 

Detailed Description

Each parameter of the input model_image is permitted to vary as a polynomial with time. Different parameters may have different order polynomials. Constant parameters should have order 0. A reference time may be specified.

Parameter list:

  • parameters[0] ... Model 1 parameters[0] 0th order term
  • parameters[1] ... Model 1 parameters[0] 1st order term
    ...
  • parameters[n1] ... Model 1 parameters[0] n1th order term
  • parameters[n1+1] ... Model 1 parameters[0] 0th order term
    ...
  • parameters[n1+n2] ... Model 1 parameters[0] n2th order term
    ...
    Note that for models that require substantial recomputation of the underlying image, this can be VERY inefficient. It will recompute the model for EVERY data point.

The documentation for this class was generated from the following files: