Defines an adaptive splined raster image for image reconstruction. The raster defined control points for an approximate spline, imposed in the u-v plane. A rectalinear, rotated fov is adaptively determined. More...

#include "model/model_polarized_image_adaptive_splined_raster.h"

Inheritance diagram for model_polarized_image_adaptive_splined_raster:

[legend]

Collaboration diagram for model_polarized_image_adaptive_splined_raster:

[legend]

Public Member Functions
	model_polarized_image_adaptive_splined_raster (size_t Nx, size_t Ny, double a=-0.5)
	Constructs a model_polarized_image_splined_raster object. Takes the extents and number of pixels in each directions (xmin and xmax are the locations of the minimum and maximum pixel centers, etc.).

void	use_numerical_visibilities ()
	State switch to select numerically computed visibilities using the machinery in model_polarized_image. Once called, all future visibilities will be computed numerically until use_analytical_visibilities() is called.

void	use_analytical_visibilities ()
	State switch to select analytically computed visibilities using the the analytical Fourier transform of the Gaussian. Once called, all future visibilities will be computed analytically until use_numerical_visibilities() is called.

virtual size_t	size () const
	A user-supplied function that returns the number of the parameters the model expects.

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.

virtual std::vector< std::complex< double > >	crosshand_visibilities (datum_crosshand_visibilities &d, double accuracy)
	Returns a vector of complex visibility corresponding to RR,LL,RL,LR in Jy computed from the image given a datum_crosshand_visibilities_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.

virtual std::complex< double >	visibility (datum_visibility &d, double accuracy)
	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 can be redefined in child classes.

virtual double	visibility_amplitude (datum_visibility_amplitude &d, double accuracy)
	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 can be redefined in child classes.

virtual double	closure_phase (datum_closure_phase &d, double accuracy)
	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 can be redefined in child classes.

virtual double	closure_amplitude (datum_closure_amplitude &d, double accuracy)
	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.

virtual std::string	model_tag () const
	A user-supplied function that returns the closure amplitudes. Takes a datum_fractional_polarization to provide access to the various 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. More...

Public Member Functions inherited from model_polarized_image
void	model_Dterms (std::vector< std::string > station_codes)
	Add D-terms, increases the number of parameters by four times the number of station codes passed. Will fail if a visibility is requested for a station for which the code has not been provided.

bool	modeling_Dterms () const
	Boolean to determine if this is fitting D-terms.

size_t	number_of_Dterms () const
	Number of D-terms (each complex number)

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.

virtual double	polarization_fraction (datum_polarization_fraction &d, double accuracy)
	A user-supplied function that returns the closure amplitudes. Takes a datum_polarization_fraction to provide access to the various 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.

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_image (std::vector< std::vector< double > > &alpha, std::vector< std::vector< double > > &beta, std::vector< std::vector< double > > &I, std::vector< std::vector< double > > &Q, std::vector< std::vector< double > > &U, std::vector< std::vector< double > > &V) const
	Provides direct access to the constructed image in all Stokes parameters. 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 > > > &VI) const
	Provides direct access to the complex visibilities. Sets a 2D grid of baselines (u,v) in lambda, and visibilites in Jy.

void	get_visibilities (std::vector< std::vector< double > > &u, std::vector< std::vector< double > > &v, std::vector< std::vector< std::complex< double > > > &RR, std::vector< std::vector< std::complex< double > > > &LL, std::vector< std::vector< std::complex< double > > > &RL, std::vector< std::vector< std::complex< double > > > &LR) const
	Provides direct access to the crosshand 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)
	Sets the image pixel values.

virtual void	generate_polarized_image (std::vector< double > parameters, std::vector< std::vector< double > > &I, std::vector< std::vector< double > > &Q, std::vector< std::vector< double > > &U, std::vector< std::vector< double > > &V, std::vector< std::vector< double > > &alpha, std::vector< std::vector< double > > &beta)
	A user-supplied function that generates and returns rectalinear grid of Stokes parameters in Jy/str located at pixels centered on angular positions alpha and beta, both specified in radians and aligned with a fiducial direction. Note that the parameter vector has had the position removed. Note that it will be assumed that alpha and beta are defined as the image appears on the sky, e.g., beta running from S to N and alpha running from E to W.

double	cubic_spline_kernel_1d (double k) const

double	cubic_spline_kernel (double u, double v) const

Private Attributes
double	_xmin

double	_xmax

const size_t	_Nx

double	_ymin

double	_ymax

const size_t	_Ny

const size_t	_size

bool	_defined_raster_grid

double	_tpdx

double	_tpdy

double	_cpa

double	_spa

const double	_a

bool	_use_analytical_visibilities

Additional Inherited Members
Protected Member Functions inherited from model_polarized_image
void	apply_Dterms (const datum_crosshand_visibilities &d, std::vector< std::complex< double > > &crosshand_vector) const
	Applies the D-terms. Checks if modeling inside and must be called in crosshand_visibilities if redefined by child classes.

void	read_and_strip_Dterm_parameters (std::vector< double > &parameters)
	Reads and remove Dterm parameters from the parameter list. Checks if modeling inside and must be called in crosshand_visibilities if redefined by child classes.

Protected Attributes inherited from model_polarized_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

std::vector< std::vector< double > >	_Q

std::vector< std::vector< double > >	_U

std::vector< std::vector< double > >	_V
	2D grid of intensities at pixel locations in Jy/str.

size_t	_size

bool	_modeling_Dterms

std::vector< std::string >	_station_codes

Protected Attributes inherited from model_crosshand_visibilities
MPI_Comm	_comm

Protected Attributes inherited from model_polarization_fraction
MPI_Comm	_comm

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

Generates four rastered pixel arrays, on which the logarithm of the intensity, logarithm of the polarization fraction, EVPA, and muV = V/sqrt(Q^2+U^2+V^2) are specified at each pixel. The dimensions of the pixel array are set at construction in the two directions. The fields of view in the two directions and orientation of the array and the location of the origin are fit parameters. Thus, the total number of parameters is \( 4 \times N_x \times N_y + 3 \). An approximate cubic spline is imposed on the constructed Stokes parameters (I,Q,U,V) with a control parameter \(a\) that should usually be set to -0.5 (default) to -0.75 to prevent excessive ringing.

Parameter list:

parameters[0] ............. log(I) pixel 1,0
parameters[1] ............. log(I) pixel 2,0 ...
parameters[Nx-2] .......... log(I) pixel Nx-3,0
parameters[Nx-1] .......... log(I) pixel 0,1
parameters[Nx] ............ log(I) pixel 1,1 ...
parameters[Nx*Ny-1] ....... log(I) pixel Nx-1,Ny-1
parameters[Nx*Ny] ......... log(m) pixel 1,0 ...
parameters[2*Nx*Ny-1] ..... log(m) pixel Nx-1,Ny-1
parameters[2*Nx*Ny] ......... EVPA pixel 1,0 ...
parameters[3*Nx*Ny-1] ..... EVPA pixel Nx-1,Ny-1
parameters[3*Nx*Ny] ......... muV pixel 1,0 ...
parameters[4*Nx*Ny-1] ..... muV pixel Nx-1,Ny-1
parameters[4*Nx*Ny] .... fov in the "x"-direction
parameters[4*Nx*Ny+1] .. fov in the "y"-direction
parameters[4*Nx*Ny+2] .. rotation angle

Warning

Member Function Documentation

std::string model_tag ( ) const

virtual

Return a string that contains a unique identifying tag for use with the ThemisPy plotting features. This function SHOULD be defined in subsequent model_image classes with a unique identifier that contains sufficient information about the hyperparameters to uniquely determine the image. By default it writes "UNDEFINED"

Reimplemented from model_polarized_image.

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

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Function Documentation