A shape where emission comes from only one direction. More...

#include <PointShape.h>

Inheritance diagram for casa::PointShape:

Public Member Functions
	PointShape ()
	The default PointShape is at the J2000 North Pole.
	PointShape (const MDirection &direction)
	Construct a point shape at the specified direction.
	PointShape (const PointShape &other)
	The copy constructor uses copy semantics.
virtual	~PointShape ()
	The destructor does nothing special.
PointShape &	operator= (const PointShape &other)
	The assignment operator uses copy semantics.
virtual ComponentType::Shape	type () const
	Return the type of shape.
virtual Double	sample (const MDirection &direction, const MVAngle &pixelLatSize, const MVAngle &pixelLongSize) const
	Calculate the proportion of the flux that is in a pixel of the specified size centered on the specified direction.
virtual void	sample (Vector< Double > &scale, const Vector< MDirection::MVType > &directions, const MDirection::Ref &refFrame, const MVAngle &pixelLatSize, const MVAngle &pixelLongSize) const
	Same as the previous function except that many directions can be sampled at once.
virtual DComplex	visibility (const Vector< Double > &uvw, const Double &frequency) const
	Return the Fourier transform of the component at the specified point in the spatial frequency domain.
virtual void	visibility (Vector< DComplex > &scale, const Matrix< Double > &uvw, const Double &frequency) const
	Same as the previous function except that many (u,v,w) points can be sampled at once.
virtual void	visibility (Matrix< DComplex > &scale, const Matrix< Double > &uvw, const Vector< Double > &frequency) const
	Same as above except with many frequencies.
virtual Bool	isSymmetric () const
	A point shape is symmetric so this function always returns True;.
virtual ComponentShape *	clone () const
	Return a pointer to a copy of this object upcast to a ComponentShape object.
virtual uInt	nParameters () const
	return the number of parameters in this shape and set/get them.
virtual void	setParameters (const Vector< Double > &newParms)
virtual Vector< Double >	parameters () const
virtual void	setErrors (const Vector< Double > &newParms)
virtual Vector< Double >	errors () const
virtual Vector< Double >	optParameters () const
virtual void	setOptParameters (const Vector< Double > &newOptParms)
virtual Bool	fromRecord (String &errorMessage, const RecordInterface &record)
	This functions convert between a Record and a PointShape.
virtual Bool	toRecord (String &errorMessage, RecordInterface &record) const
	Convert the class to an Record representation.
virtual Bool	convertUnit (String &, const RecordInterface &)
	Convert the parameters of the component to the specified units.
virtual Bool	ok () const
	Function which checks the internal data of this class for consistent values.
virtual const ComponentShape *	getPtr () const
	return a pointer to this object.
virtual String	sizeToString () const

Private Member Functions
Double	dirIsInPixel (Double longSize, Double latSize, Double nearSize, const MDirection::MVType &dirValue, const MDirection::MVType *compDirValue) const
	FInd out if a direction is located within a pixel.

Detailed Description

A shape where emission comes from only one direction.

Intended use:

Public interface

 <h3>Review Status</h3><dl><dt>Date Reviewed:<dd>yyyy/mm/dd<dt>Test programs:<dd>tPointShape<dt>Demo programs:<dd>dPointShape</dl>

Prerequisite

ComponentShape

Synopsis

This class represents the shape of components where the emission comes from only one point in the sky.

This class like the other component shapes becomes more useful when used through the SkyComponent class, which incorporates the flux and spectral variation of the emission, or through the ComponentList class, which handles groups of SkyComponent objects.

For a point shape all the emission comes only from the reference direction which is specified in celestial co-ordinates, using a MDirection object. The direction can be specified both in the constructor or with the setRefDirection function.

The sample member functions are used to determine the proportion of flux the component at any point on the sky. For a point component this is either zero or one depending on whether the specified pixel contains the point source or not.

The visibility functions return the Fourier transform of the component at a specified spatial frequency. For a point shape the Fourier transform is a constant value. Hence these functions return one, regardless of the input parameters.

This class also contains functions (toRecord & fromRecord) which perform the conversion between Records and PointShape objects. These functions define how a PointShape object is represented in glish. The format of the record that is generated and accepted by these functions is:

    c := [type = 'point',
          direction = [type = 'direction',
                       refer = 'j2000',
                       m0 = [value = 0, unit = 'deg']
                       m1 = [value = 0, unit = 'deg']
                      ]
         ]

The direction field contains a record representation of a direction measure and its format is defined in the Measures module. Its refer field defines the reference frame for the direction and the m0 and m1 fields define the latitude and longitude in that frame.

Example

Suppose I had an image of a region of the sky and we wanted to subtract a point source from it. This could be done as follows:

Construct a SkyComponent with to represent the point source
Project the component onto an image
Convolve the image by the point spread function
subtract the convolved model from the dirty image.

Shown below is the code to perform the first step in this process, ie construct the SkyComponent. This example is also available in the dPointShape.cc file. Note that it is more accurate to do subtraction of point components in the (u,v) domain

     MDirection J1934_dir;
     { // get the right direction into J1934_dir
       Quantity J1934_ra; MVAngle::read(J1934_ra, "19:39:");
       Quantity J1934_dec; MVAngle::read(J1934_dec, "-63.43.");
       J1934_dir = MDirection(J1934_ra, J1934_dec, MDirection::J2000);
     }
     { // One way to construct the SkyComponent
       SkyComponent J1934(ComponentType::POINT, ComponentType::CONSTANT_SPECTRUM);
       J1934.shape().setRefDirection(J1934_dir);
       J1934.flux() = Flux<Double>(6.28, 0.1, 0.15, 0.01);
       printShape(J1934.shape());
     }
     { // An alternative way to construct the SkyComponent
       const Flux<Double> flux(6.28, 0.1, 0.15, 0.01);
       const PointShape shape(J1934_dir);
       const ConstantSpectrum spectrum;
       SkyComponent component(flux, shape, spectrum);
       printShape(component.shape());
     }

Note how the member functions of the PointShape class (the setDirection function) are accessable through the shape function in the SkyComponent class. The printShape function is the example shown for the ComponentShape class.

To Do

Use Measures & Quanta in the interface to the visibility functions.

Definition at line 152 of file PointShape.h.

Constructor & Destructor Documentation

casa::PointShape::PointShape ( )

The default PointShape is at the J2000 North Pole.

casa::PointShape::PointShape ( const MDirection & direction )

Construct a point shape at the specified direction.

casa::PointShape::PointShape ( const PointShape & other )

The copy constructor uses copy semantics.

virtual casa::PointShape::~PointShape ( ) [virtual]

The destructor does nothing special.

Member Function Documentation

virtual ComponentShape* casa::PointShape::clone ( ) const [virtual]

Return a pointer to a copy of this object upcast to a ComponentShape object.

The class that uses this function is responsible for deleting the pointer. This is used to implement a virtual copy constructor.

virtual Bool casa::PointShape::convertUnit	(	String &	,
		const RecordInterface &
	)		`[virtual]`

Double casa::PointShape::dirIsInPixel	(	Double	longSize,
		Double	latSize,
		Double	nearSize,
		const MDirection::MVType &	dirValue,
		const MDirection::MVType *	compDirValue
	)		const `[private]`

virtual Bool casa::PointShape::fromRecord	(	String &	errorMessage,
		const RecordInterface &	record
	)		`[virtual]`

virtual Double casa::PointShape::sample	(	const MDirection &	direction,
		const MVAngle &	pixelLatSize,
		const MVAngle &	pixelLongSize
	)		const `[virtual]`

virtual void casa::PointShape::sample	(	Vector< Double > &	scale,
		const Vector< MDirection::MVType > &	directions,
		const MDirection::Ref &	refFrame,
		const MVAngle &	pixelLatSize,
		const MVAngle &	pixelLongSize
	)		const `[virtual]`

virtual Bool casa::PointShape::toRecord	(	String &	error,
		RecordInterface &	outRecord
	)		const `[virtual]`

virtual DComplex casa::PointShape::visibility	(	const Vector< Double > &	uvw,
		const Double &	frequency
	)		const `[virtual]`

virtual void casa::PointShape::visibility	(	Vector< DComplex > &	scale,
		const Matrix< Double > &	uvw,
		const Double &	frequency
	)		const `[virtual]`

virtual void casa::PointShape::visibility	(	Matrix< DComplex > &	scale,
		const Matrix< Double > &	uvw,
		const Vector< Double > &	frequency
	)		const `[virtual]`

Public Member Functions

Private Member Functions