model_polarized_image_constant_polarization Class Reference
Defines a class that takes a model_image and applies a constant polarization, returning a model_polarized_image instance. More...
#include "model/model_polarized_image_constant_polarization.h"
Inheritance diagram for model_polarized_image_constant_polarization:
Collaboration diagram for model_polarized_image_constant_polarization:
Public Member Functions | |
| model_polarized_image_constant_polarization (model_image &intensity_model) | |
 Public Member Functions inherited from model_polarized_image | |
| virtual size_t | size () const |
| A user-supplied function that returns the number of the parameters the model expects. | |
| 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. | |
| 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) |
| A user-supplied function that generates and returns rectalinear grid of intensities 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. | |
| 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. | |
| 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 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 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. | |
| 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. | |
| 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. | |
| virtual void | set_mpi_communicator (MPI_Comm comm) |
| 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... | |
| virtual std::string | model_tag () const |
| 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". | |
Private Attributes | |
| model_image & | _intensity_model |
| double | _polarization_fraction |
| double | _polarization_EVPA |
| double | _polarization_mu |
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 > ¶meters) |
| 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
Takes a model_image object which defines the Stokes I map model and applies a constant, uniform polarization fraction and orientation.
Parameter list:
- parameters[0] ... model_image object parameters
- parameters[N] ... model_image object parameters
- parameters[N+1] . Polarization fraction
- parameters[N+2] . Polarization EVPA
- parameters[N+3] . Polarization ellipticity (i.e., \( \tan[V/\sqrt(Q^2+U^2) \)]
Note that the polarization angle is stripped off of the end as we assume that it is included in the underlying model_image object.
- Warning
- If fitting the crosshand visibilities, you may need to make sure that the image has the shift freedom (i.e., offset in x,y). This may be created from a normal model_image using model_image_sum.
Member Function Documentation
|
privatevirtual |
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.
Reimplemented from model_polarized_image.
Here is the call graph for this function:
The documentation for this class was generated from the following files: