class AliITSRealignTracks: public AliAlignmentTracks

 Assignment operator

destructor

Method to select the fitter: 0 for AliTrackFitterRieman (use this for helixes)
                             1 for AliTrackFitterKalman
minTrackPoint defines the minimum number of points (not rejected by the fit itself)
a track should have to fit it

Method to select the minimizer: "minuit" for AliTrackFitterChi2 (numerical minimization by MINUIT)
                                "fast" for AliTrackResidualsFast
                                "linear" for AliTrackResidualsLinear
                                "minuitnorot" for AliTrackFitterChi2 by
 coord[6] allows to fix the degrees of freedom in the minimization (e.g. look only for tranlsations,
       or only for rotations). The coord are: dTx,dTy,dTz,dPsi,dTheta,dPhi where "d" stands for
       "differential" and "T" for translation. If coord[i] is set to kTRUE then the i coord is fixed
       When a coordinate is fixed the value returnd for it is 0
 minnpoints fix the minimum number of residuals to perform the minimization: it's not safe
     to align a module with a small number of track passing through it since the results could be
     not reliable. For single modules the number of residuals and the number of tracks passing
     through it and accepted bu the fit procedure coincide. This is not the case for sets of modules,
     since a given track can pass through two or more modules in the set (e.g a cosmic track can give
     two cluster on a layer)

SigmaY is the value of the error along the track direction assigned
to the AliTrackPoint constructed from the extrapolation of the fit of a track
to the module one is realigning. This error simulate the uncertainty on the
position of the cluster in space due to the misalingment of the module (i.e.
you don't the real position and orientation of the plane of the desired extrapolation
but you rely on the fit and consider the point to lie along the track)

 Initialize the alignment objects array

 Initialize and reset to 0 the array with the information on correlation

Initialize the Survey Objects. There is the possibility to set them equal to external objects
   stored in file filename. Otherwuse they are set equal to 0 and with default values for the variances
infinite: set the cov matrix to extremly large values, so that the results of a minimization
   are never rejected by the comparison with the survey
factor: multiplication factor for the variances of the cov. matrix of the survey obj.

 Reset the alignment objects in volids or all if all=kTRUE

Align each SPD module with at least minNtracks passing through it with respect to SSD
The selection based on the minimum number of tracks is a fast one:
 the number considere here doesn't coincide with the tracks effectively used then in the
 minimization, it's just the total number of tracks in the sample passing through the module
 The procedure is iterated "iterations" times

 Align a set of detector volumes.
 Tracks are fitted only within
 the range defined by the user
 (by layerRangeMin and layerRangeMax)
 or within the set of volidsfit
 Repeat the procedure 'iterations' times

Align the SPD barrel "iterations" times

Align a SPD Half barrel "iterations" times
method 0 : align SPDHalfBarrel Up without using the points on SPD Half Barrel down in the fits (only outer layers)
method 1 : align SPDHalfBarrel Down without using the points on SPD Half Barrel up in the fits (only outer layers)
method 10 : align SPDHalfBarrel Up using also the points on SPD Half Barrel down in the fits (and points on outer layers)
method 11 : align SPDHalfBarrel Down using also the points on SPD Half Barrel up in the fits (and points on outer layers)

Align the layer "layer" iterations times

Align the SPD sector "sector" with respect to outer layers iterations times

Align the SPD sector "sector" with respect to the other SPD sectors iterations times

Align SPD sectors defined in "sectorsIN" with respect to
SPD sectors defined in "sectorsFit" iterations time

Align SPD staves defined by staves and sectorsIN with respect to sectorsFit volumes iterations times

Align the layer "layer" with respect to SPD Half Barrel Up (updowon=0)
or Down (updown=1) iterations times

Align the layer "layer" with respect to SPD sector "sector" iterations times

Align the SPD Half Barrel Up[Down] with respect to HB Down[Up] iterations time if
updown=0[1]

Align the SPD Half Barrel Down with respect to sector "sector" iterations times

OBSOLETE METHOD: Align the SPD1 modules of sector "sector" with respect
 to the other SPD volumes iterations times

TEMPORARY METHOD: perform an average of the values of the parameters of the AlignObjs
 defined by the array volIDs up to lastVolid position in this array
The aim of such a method is to look for collective movement of a given set of modules

 This method gets the volID Array for the chosen sectors.
 You have to pass an array with a 1 for each selected sector.
 i.e. sectors[10] = {1,1,0,0,0,0,0,0,1,0} -> Sector 0, 1, 9 selected.

Select between the modules specified by their volUIDs in volidsIN only those
 of a given layer "layer"

!BE CAREFUL: If an index is repeated into vol1 or into vol2 will be repeated also in the final array

Excludes the modules defined by their volUID in the array volidsToExclude from the array volStart

returns a TArrayI with the volUIDs of the modules of the layers
specified into *layer

Open the file "filename" which is expected to contain
a TClonesArray named "ITSAlignObjs" with stored a set of AlignObjs
returns an array with the volumes UID of the modules considered realigned

TEPMORARY METHOD: method to switch on/off the drawing of histograms
 if refresh=kTRUE deletes the old histos and constructs new ones

Delete the pointers to the histograms

Initialize the histograms to monitor the results

Updates the histograms to monitor the results. Only the histograms
of the volumes specified in *volids will be updated.
 iter is just a flag for the names of the histo
 color specifies the color of the lines of the histograms for this update

Writes the histograms for the monitoring of the results
 in a file named "outfile"

  Int_t LoadPoints(const TArrayI *volids, AliTrackPointArray** &points);