The cleaning works like this. The user constructs a ClarkCleanModel by specifying an initial model of the sky. This can by be one,two,three... dimensional depending on the dimension of the psf (see below). The user then constructs a class which implements the forward equation between the model and the dirty image. Typically this will be the ConvolutionEquation class, although any class which has a ResidualEquation interface will be work (but perhaps very slowly, as the ConvolutionEquation class has member functions optimised for cleaning)
The user then calls the solve() function (with the appropriate equation class as an arguement), and this class will perform the Clark clean. The various clean parameters are set (prior to calling solve) using the functions derived from the Iterate class, in particular setGain(), setNumberIterations() & setThreshold() (to set a flux limit).
The solve() function does not return either the deconvolved model or the residuals. The solved model can be obtained using the getModel() function (derived from ArrayModel()) and the residual can be obtained using the residual() member function of the Convolution/Residual Equation Class.
The size and shape of the model used in this class MUST be the same as the convolved data (Dirty Image), stored in the companion ResidualEquation Class. However the model (and convolved data) can have more dimensions than the psf, as well as a different size (either larger or smaller). When the dimensionality is different the cleaning is done independendtly in each "plane" of the model. (Note this has not been implemented yet but is relatively simple to do if necessary).
This multi-dimensionalty is exploited when cleaning arrays of StokesVectors. Here the Array of StokesVectors is decomposed into a stack of 4 Floating point arrays and the cleaning is done on all the the arrays simultaneosly. The criterion for choosing the brightest pixel has been generalised by using the "length" of the Stokesvector in 4 dimensional space.
A companion class to this one is MaskedClarkCleanModel. This provides the same functionality but is used with MaskedArrays which indicate which regions of the model to search for clean components.
Matrix<Float> psf(12,12), dirty(10,10), initialModel(10,10);
...put appropriate values into psf, dirty, & initialModel....
ClarkCleanModel<Float> deconvolvedModel(initialModel);
ConvolutionEquation convEqn(psf, dirty);
deconvolvedModel.setGain(0.2);
deconvolvedModel.setNumberIterations(1000);
Bool convWorked = deconvolvedModel.solve(convEqn);
Array<Float> finalModel, residuals;
if (convWorked){
finalModel = deconvolvedModel.getModel();
ConvEqn.residual(deconvolvedModel, finalResidual);
}
Set/get the progress display
Using a Clark clean deconvolution proceedure solve for an improved estimate of the deconvolved object. The convolution/residual equation contains the psf and dirty image. When called with a ResidualEquation arguement a quite general interface is used that is slow. The convolution equation contains functions that speed things up. The functions return False if the deconvolution could not be done.
These functions set various "knobs" that the user can tweak and are specific to the Clark clean algorithm. The more generic parameters ie. clean gain, and maximum residual fluxlimit, are set using functions in the Iterate base class. The get functions return the value that was actually used after the cleaning was done.
Set the size of the histogram used to determine how many pixels are "active" in a minor iteration. Default value is 1000 is OK for everything except very small cleans.
These functions set various "knobs" that the user can tweak and are specific to the Clark clean algorithm. The more generic parameters ie. clean gain, and maximum residual fluxlimit, are set using functions in the Iterate base class. The get functions return the value that was actually used after the cleaning was done.
Set the maximum number of minor iterations to perform for each major cycle.
These functions set various "knobs" that the user can tweak and are specific to the Clark clean algorithm. The more generic parameters ie. clean gain, and maximum residual fluxlimit, are set using functions in the Iterate base class. The get functions return the value that was actually used after the cleaning was done.
Set and get the initial number of iterations
These functions set various "knobs" that the user can tweak and are specific to the Clark clean algorithm. The more generic parameters ie. clean gain, and maximum residual fluxlimit, are set using functions in the Iterate base class. The get functions return the value that was actually used after the cleaning was done.
Set the maximum number of major cycles to perform
These functions set various "knobs" that the user can tweak and are specific to the Clark clean algorithm. The more generic parameters ie. clean gain, and maximum residual fluxlimit, are set using functions in the Iterate base class. The get functions return the value that was actually used after the cleaning was done.
Set the maximum number of active pixels to use in the minor iterations. The specified number can be exceeded if the topmost bin of the histogram contains more pixels than specified here. The default is 10,000 which is suitable for images of 512by512 pixels. Reduce this for smaller images and increase it for larger ones.
These functions set various "knobs" that the user can tweak and are specific to the Clark clean algorithm. The more generic parameters ie. clean gain, and maximum residual fluxlimit, are set using functions in the Iterate base class. The get functions return the value that was actually used after the cleaning was done.
Set the maximum exterior psf value. This is used to determine when to stop the minor itartions. This is normally determined from the psf and the number set here is only used if this cannot be determined. The default is zero.
These functions set various "knobs" that the user can tweak and are specific to the Clark clean algorithm. The more generic parameters ie. clean gain, and maximum residual fluxlimit, are set using functions in the Iterate base class. The get functions return the value that was actually used after the cleaning was done.
An exponent on the F(m,n) factor (see Clark[1980]) which influences how quickly active pixels are treated as unreliable. Larger values mean more major iterations. The default is zero. I have no experience on when to use this factor.
These functions set various "knobs" that the user can tweak and are specific to the Clark clean algorithm. The more generic parameters ie. clean gain, and maximum residual fluxlimit, are set using functions in the Iterate base class. The get functions return the value that was actually used after the cleaning was done.
The structure of various AIPS++ algorithms creates major cycles around the Clark Clean (or other deconvolution algrithms. The cycleSpeedup parameter causes the threshold to edge up as thresh = thresh_0 * 2^( iter/cycleSpeedup ); ignored if cycleSpeedup <= 0.
These functions set various "knobs" that the user can tweak and are specific to the Clark clean algorithm. The more generic parameters ie. clean gain, and maximum residual fluxlimit, are set using functions in the Iterate base class. The get functions return the value that was actually used after the cleaning was done.
We are overwriting Iterate's threshold() method to put out speedup in it
These functions set various "knobs" that the user can tweak and are specific to the Clark clean algorithm. The more generic parameters ie. clean gain, and maximum residual fluxlimit, are set using functions in the Iterate base class. The get functions return the value that was actually used after the cleaning was done.
The user can be asked whether to stop after every minor cycle
These functions set various "knobs" that the user can tweak and are specific to the Clark clean algorithm. The more generic parameters ie. clean gain, and maximum residual fluxlimit, are set using functions in the Iterate base class. The get functions return the value that was actually used after the cleaning was done.