* provided "as is" without express or implied warranty. *
**************************************************************************/
+//---------------------------------
+//Class to perform the realignment if the Inner Tracking System
+//with an iterative approach based on track to cluster residuals
+// minimization. A chi2 function of the residuals is minimized with
+//respect to alignment parameters. The class allows both single module
+//realignment and set of modules realignment. Tracks are fitted with
+//AliTrackFitter* fitters. AliTrackFitterKalman is more suited for
+//straight line (e.g. cosmic in the absence of magnetic field) but can't
+//work with helixes. AliTrackFitterRieman is suited for helixes.
+//The minimization is performed by AliTrackResiduals* classes: default
+//one is AliTrackResidualsFast (analytic minimization by inversion).
+//For numerical minimization using MINUIT, use AliTrackResidualChi2.
+//Methods are present to defined both the set of modules where the tracks
+//are fittef and the set of modules which are to be realigned
+//The main method is AlignVolumesITS
+//
+//Class by: A. Rossi, andrea,rossi@ts.infn.it
-#include <TArray.h>
#include <TFile.h>
#include <TStopwatch.h>
-#include <TArray.h>
#include <TNtuple.h>
#include <TClonesArray.h>
#include <TMath.h>
-#include <TGeoManager.h>
-#include <TSystem.h>
-#include <TGeoMatrix.h>
#include <TGraph.h>
#include <TCanvas.h>
#include <TH1F.h>
#include "AliITSRealignTracks.h"
-#include "AliAlignmentTracks.h"
#include "AliAlignObjParams.h"
#include "AliAlignObj.h"
#include "AliGeomManager.h"
#include "AliTrackResidualsFast.h"
#include "AliTrackResidualsChi2.h"
#include "AliTrackResidualsLinear.h"
+
#include "AliLog.h"
+#include <TSystem.h>
+#include <TGeoManager.h>
+
+class AliAlignmentTracks;
+class TGeoMatrix;
+class TArray;
+
/* $Id$ */
ClassImp(AliITSRealignTracks)
-const Int_t referSect=2;
+const Int_t kreferSect=2;
AliITSRealignTracks::AliITSRealignTracks(TString minimizer,Int_t fit,Bool_t covUsed,TString fileintro,TString geometryfile,TString misalignmentFile,TString startingfile):
fSurveyObjs(0),
fgeomfilename(),
fmintracks(),
- fCovIsUsed(covUsed),
fUpdateCov(kFALSE),
fVarySigmaY(kFALSE),
fCorrModules(0),
fSurveyObjs(new AliAlignObj**(*realignTracks.fSurveyObjs)),
fgeomfilename(realignTracks.fgeomfilename),
fmintracks(realignTracks.fmintracks),
- fCovIsUsed(realignTracks.fCovIsUsed),
fUpdateCov(realignTracks.fUpdateCov),
fVarySigmaY(realignTracks.fVarySigmaY),
fCorrModules(new Double_t *(*realignTracks.fCorrModules)),
//_____________________________
Bool_t AliITSRealignTracks::SelectFitter(Int_t fit,Int_t minTrackPoint){
+ //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
if(fit==1){
AliTrackFitterKalman *fitter= new AliTrackFitterKalman();
Bool_t AliITSRealignTracks::SelectMinimizer(TString minimizer,Int_t minpoints,const Bool_t *coord){
+ //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)
+
AliTrackResiduals *res;
if(minimizer=="minuit"){
res = new AliTrackResidualsChi2();
//____________________________________
void AliITSRealignTracks::SetVarySigmaY(Bool_t varysigmay,Double_t sigmaYfixed){
+ //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)
+
fVarySigmaY=varysigmay;
if(!varysigmay){
for(Int_t siter=0;siter<5;siter++){
fTrackFitter->SetMinNPoints(2);
SetCovUpdate(kFALSE);
- AlignSPDHalfBarrelToSectorRef(referSect,3);
+ AlignSPDHalfBarrelToSectorRef(kreferSect,3);
// AlignSPDBarrel(1);
// if(siter==0)SetCovUpdate(kFALSE);
// AlignSPDHalfBarrel(0,3);
// SetCovUpdate(kTRUE);
AlignSPDHalfBarrelToHalfBarrel(1,3);
- // AlignSPDHalfBarrelToSectorRef(referSect,3);
+ // AlignSPDHalfBarrelToSectorRef(kreferSect,3);
for(Int_t sector=0;sector<10;sector++){
SetMinNtracks(100);
- if(sector==referSect)continue;
+ if(sector==kreferSect)continue;
AlignSPDSectorWithSectors(sector,1);
}
for(Int_t lay=1;lay<=6;lay++){
- if(!AlignLayerToSector(lay,referSect,3))AlignLayerToSPDHalfBarrel(lay,0,3);
+ if(!AlignLayerToSector(lay,kreferSect,3))AlignLayerToSPDHalfBarrel(lay,0,3);
}
AlignSPDHalfBarrel(0,3);
//______________________________________________________________________________
Bool_t AliITSRealignTracks::InitSurveyObjs(Bool_t infinite,Double_t factor,TString filename,TString arrayName){
-
+ //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.
+
if(fSurveyObjs)DeleteSurveyObjs();
Bool_t fromfile=kFALSE;
TFile *surveyObj;
//______________________________________________________________________________
-Int_t AliITSRealignTracks::CheckWithSurvey(Double_t factor,TArrayI *volids){
+Int_t AliITSRealignTracks::CheckWithSurvey(Double_t factor,const TArrayI *volids){
// Check the parameters of the alignment objects in volids (or of all objects if volids is null)
// are into the boundaries set by the cov. matrix of the survey objs
//______________________________________________-
void AliITSRealignTracks::DeleteSurveyObjs()
-{
+{//destructor for the survey objs. array
+
if(!fSurveyObjs)return;
// Delete the alignment objects array
for (Int_t iLayer = 0; iLayer < (AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer); iLayer++) {
}
//_________________________________________
-Bool_t AliITSRealignTracks::FirstAlignmentLayers(Bool_t *layers,Int_t minNtracks,Int_t iterations,Bool_t fitall,TArrayI *volidsSet){
+Bool_t AliITSRealignTracks::FirstAlignmentLayers(const Bool_t *layers,Int_t minNtracks,Int_t iterations,Bool_t fitall,TArrayI *volidsSet){
//Align all modules in the set of layers independently according to a sequence based on the number of tracks passing through a given module
//__________________________________________
Bool_t AliITSRealignTracks::FirstAlignmentSPD(Int_t minNtracks,Int_t iterations,Bool_t fitall,TArrayI *volidsSet){
+
+ //OBSOLETE METHOD: perform a stand-alone realignment of the SPD modules
+ // based on a sequence constructed accordingly to the number of tracks
+ // passing through each module
BuildIndex();
//__________________________________
Bool_t AliITSRealignTracks::SPDmodulesAlignToSSD(Int_t minNtracks,Int_t iterations){
-
+ //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
Int_t volSSD[6]={0,0,0,0,1,1};
TArrayI *volOuter=GetLayersVolUID(volSSD);
TArrayI *voluid=new TArrayI(1);
//______________________________________________
Bool_t AliITSRealignTracks::AlignSPDBarrel(Int_t iterations){
+ //Align the SPD barrel "iterations" times
Int_t size=0,size2=0;
Int_t layers[6]={1,1,0,0,0,0};
//______________________
Bool_t AliITSRealignTracks::AlignSPDHalfBarrel(Int_t method,Int_t iterations){
-
+ //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)
+
Int_t size=0,size2=0;
Int_t layers[6]={0,0,1,1,1,1};
Int_t sectorsUp[10]={1,1,1,1,1,0,0,0,0,0};
//______________________________________________________
Bool_t AliITSRealignTracks::AlignLayer(Int_t layer,Int_t iterations){
+ //Align the layer "layer" iterations times
Int_t size=0,size2=0;
Int_t layers[6]={0,0,0,0,0,0};
//___________________________________________
-Bool_t AliITSRealignTracks::AlignLayersToLayers(Int_t *layer,Int_t iterations){
+Bool_t AliITSRealignTracks::AlignLayersToLayers(const Int_t *layer,Int_t iterations){
+ //Align the set of layers A with respect to the set of layers B iterations time.
+ //The two sets A and B are defined into *layer==layer[6] the following way:
+ // layer[i]=0 the layer is skipped both in the fits than in the minimization
+ // layer[i]=1 the layer is skipped in the fits and considered in the minimization
+ // layer[i]=2 the layer is considered in the fits and skipped in the minimization
+ // layer[i]=3 the layer is considered both in the fits and in the minimization
+
UShort_t volid;
Int_t size=0,size2=0,j=0,k=0;
Int_t iLayer;
//______________________________________________
Bool_t AliITSRealignTracks::AlignSPDSectorToOuterLayers(Int_t sector,Int_t iterations){
+ //Align the SPD sector "sector" with respect to outer layers iterations times
Int_t layers[6]={0,0,1,1,1,1};
//______________________________________________
Bool_t AliITSRealignTracks::AlignSPDSectorWithSectors(Int_t sector,Int_t iterations){
-
+ //Align the SPD sector "sector" with respect to the other SPD sectors iterations times
Int_t sectorsIN[10]={0,0,0,0,0,0,0,0,0,0};
Int_t sectorsFit[10]={1,1,1,1,1,1,1,1,1,1};
//___________________________________________________
Bool_t AliITSRealignTracks::AlignSPDSectorsWithSectors(Int_t *sectorsIN,Int_t *sectorsFit,Int_t iterations){
+ //Align SPD sectors defined in "sectorsIN" with respect to
+ //SPD sectors defined in "sectorsFit" iterations time
TArrayI *volIDs=GetSPDSectorsVolids(sectorsIN);
TArrayI *volIDsFit=GetSPDSectorsVolids(sectorsFit);;
//___________________________________________________
Bool_t AliITSRealignTracks::AlignSPDStaves(Int_t *staves,Int_t *sectorsIN,Int_t *sectorsFit,Int_t iterations){
+ //Align SPD staves defined by staves and sectorsIN with respect to sectorsFit volumes iterations times
TArrayI *volIDs=GetSPDStavesVolids(sectorsIN,staves);
TArrayI *volIDsFit=GetSPDSectorsVolids(sectorsFit);
//___________________________________________
Bool_t AliITSRealignTracks::AlignLayerToSPDHalfBarrel(Int_t layer,Int_t updown,Int_t iterations){
+ //Align the layer "layer" with respect to SPD Half Barrel Up (updowon=0)
+ //or Down (updown=1) iterations times
+
Int_t sectorsDown[10]={0,0,0,0,0,1,1,1,1,1};
//___________________________________________
Bool_t AliITSRealignTracks::AlignLayerToSector(Int_t layer,Int_t sector,Int_t iterations){
-
+ //Align the layer "layer" with respect to SPD sector "sector" iterations times
+
if(sector>9){
printf("Wrong Sector selection! \n");
return kFALSE;
//_______________________________________________
Bool_t AliITSRealignTracks::AlignSPDHalfBarrelToHalfBarrel(Int_t updown,Int_t iterations){
+ //Align the SPD Half Barrel Up[Down] with respect to HB Down[Up] iterations time if
+ //updown=0[1]
Int_t sectorsDown[10]={0,0,0,0,0,1,1,1,1,1};
//_______________________
Bool_t AliITSRealignTracks::AlignSPDHalfBarrelToSectorRef(Int_t sector,Int_t iterations){
+ //Align the SPD Half Barrel Down with respect to sector "sector" iterations times
Int_t sectorsIN[10]={0,0,0,0,0,1,1,1,1,1};
Int_t sectorsFit[10]={0,0,0,0,0,0,0,0,0,0};
}
//_________________________________________
Bool_t AliITSRealignTracks::AlignSPD1SectorRef(Int_t sector,Int_t iterations){
+ //OBSOLETE METHOD: Align the SPD1 modules of sector "sector" with respect
+ // to the other SPD volumes iterations times
Int_t sectorsIN[10]={0,0,0,0,0,0,0,0,0,0};
Int_t sectorsFit[10]={1,1,1,1,1,1,1,1,1,1};
//_____________________________________________
AliAlignObjParams* AliITSRealignTracks::MediateAlignObj(TArrayI *volIDs,Int_t lastVolid){
+ //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
+
UShort_t volid;
TGeoHMatrix hm;
//________________________________________________
-TArrayI* AliITSRealignTracks::GetSPDStavesVolids(Int_t *sectors,Int_t* staves){
+TArrayI* AliITSRealignTracks::GetSPDStavesVolids(const Int_t *sectors,const Int_t* staves){
// This method gets the volID Array for the chosen staves into the
}
//________________________________________________
-TArrayI* AliITSRealignTracks::GetSPDSectorsVolids(Int_t *sectors)
+TArrayI* AliITSRealignTracks::GetSPDSectorsVolids(const Int_t *sectors)
{
//
// This method gets the volID Array for the chosen sectors.
}
//___________________________________
-TArrayI* AliITSRealignTracks::GetLayersVolUID(Int_t *layer){
+TArrayI* AliITSRealignTracks::GetLayersVolUID(const Int_t *layer){
+
+ //return a TArrayI with the volUIDs of the modules into the set of layers
+ //defined by layer[6]
TArrayI *out=new TArrayI(2198);
Int_t last=0;
//_________________
TArrayI* AliITSRealignTracks::SelectLayerInVolids(const TArrayI *volidsIN,AliGeomManager::ELayerID layer){
+ //Select between the modules specified by their volUIDs in volidsIN only those
+ // of a given layer "layer"
Int_t size=volidsIN->GetSize();
Int_t count=0;
//______________________________________________
TArrayI* AliITSRealignTracks::IntersectVolArray(const TArrayI *vol1,const TArrayI *vol2){
+
+ //Perform the intersection between the array vol1 and vol2
Int_t size1=vol1->GetSize();
Int_t size2=vol2->GetSize();
//_________________________________________
TArrayI* AliITSRealignTracks::JoinVolArrays(const TArrayI *vol1,const TArrayI *vol2){
- //!BE CAREFUL: If an index is repeated in vol1 or vol2 will be repeated also in the final array
+ //!BE CAREFUL: If an index is repeated into vol1 or into vol2 will be repeated also in the final array
Int_t size1=vol1->GetSize();
Int_t size2=vol2->GetSize();
volidOut->AddAt(volid,k);
}
- for(Int_t k=0;k<size1;k++){
+ for(Int_t k=0;k<size2;k++){
found=kFALSE;
- volid=vol1->At(k);
- for(Int_t j=0;j<size2;j++){
- if(vol2->At(j)==volid)found=kTRUE;
+ volid=vol2->At(k);
+ for(Int_t j=0;j<size1;j++){
+ if(volidOut->At(j)==volid)found=kTRUE;
}
if(!found){
volidOut->AddAt(volid,size1+count);
//______________________________________
TArrayI* AliITSRealignTracks::ExcludeVolidsFromVolidsArray(const TArrayI *volidsToExclude,const TArrayI *volStart){
+ //Excludes the modules defined by their volUID in the array volidsToExclude from the array volStart
Int_t size1=volidsToExclude->GetSize();
Int_t size2=volStart->GetSize();
//________________________________________
-TArrayI* AliITSRealignTracks::GetLayerVolumes(Int_t *layer){
+TArrayI* AliITSRealignTracks::GetLayerVolumes(const Int_t *layer){
+ //returns a TArrayI with the volUIDs of the modules of the layers
+ //specified into *layer
TArrayI *out=new TArrayI(2198);
Int_t last=0;
//______________________________
TArrayI* AliITSRealignTracks::GetAlignedVolumes(char *filename){
+ //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
+
if(gSystem->AccessPathName(filename)){
printf("Wrong Realignment file name \n");
return 0x0;
//________________________________________
void AliITSRealignTracks::SetDraw(Bool_t draw,Bool_t refresh){
+ //TEPMORARY METHOD: method to switch on/off the drawing of histograms
+ // if refresh=kTRUE deletes the old histos and constructs new ones
if(refresh){
// WriteHists();
}
void AliITSRealignTracks::DeleteDrawHists(){
+ //Delete the pointers to the histograms
+
for (Int_t iLayer = 0; iLayer < (AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer); iLayer++) {
for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++) {
delete fAlignDrawObjs[iLayer][iModule];
}
void AliITSRealignTracks::InitDrawHists(){
+ //Initialize the histograms to monitor the results
+
Int_t nLayers = AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer;
fAlignDrawObjs = new AliAlignObj**[nLayers];
for (Int_t iLayer = 0; iLayer < (AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer); iLayer++) {
}
void AliITSRealignTracks::UpdateDraw(TArrayI *volids,Int_t iter,Int_t color){
-
+ //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
TString name="hX_";
name+=iter;
}
void AliITSRealignTracks::WriteHists(const char *outfile){
+ //Writes the histograms for the monitoring of the results
+ // in a file named "outfile"
TFile *f=new TFile(outfile,"RECREATE");
f->cd();
#ifndef ALIITSREALIGNTRACKS_H
#define ALIITSREALIGNTRACKS_H
-#include <TArray.h>
-#include <TFile.h>
-#include <TArray.h>
-#include <TGraph.h>
-#include <TCanvas.h>
+
+//Class to perform the realignment if the Inner Tracking System
+//with an iterative approach based on track to cluster residuals
+// minimization. More details in .cxx file
+//
+//Class by: A. Rossi, andrea,rossi@ts.infn.it
+
+
#include "AliGeomManager.h"
#include "AliAlignmentTracks.h"
-#include "AliAlignObjParams.h"
+
+class TArray;
+class TGraph;
+class TCanvas;
+class TArray;
+class TFile;
+class AliAlignObjParams;
+
/* $Id$ */
+
class AliITSRealignTracks: public AliAlignmentTracks {
public:
fSurveyObjs(0),
fgeomfilename(),
fmintracks(0),
- fCovIsUsed(kFALSE),
fUpdateCov(kFALSE),
fVarySigmaY(kFALSE),
fCorrModules(0),
fgrIterRMSTheta(0),
fgrIterMeanPhi(0),
fgrIterRMSPhi(0)
- {}
+ {SetCovIsUsed(kFALSE);}
AliITSRealignTracks(TString minimizer,Int_t fit=0,Bool_t covUsed=kFALSE,TString fileintro="AliTrackPoints.root",TString geometryfile="geometry.root",TString misalignmentFile="",TString startingfile="");
AliITSRealignTracks(const AliITSRealignTracks &realignTracks);
void ResetCorrModules();
void DeleteSurveyObjs();
void SetLimitCorr(Double_t limit=0.1){fLimitCorr=limit;}
- Int_t CheckWithSurvey(Double_t factor=2.,TArrayI *volids=0x0);
+ Int_t CheckWithSurvey(Double_t factor=2.,const TArrayI *volids=0x0);
Bool_t SelectFitter(Int_t fit,Int_t minTrackPoint=2);
Bool_t SelectMinimizer(TString minimizer,Int_t minpoints=1,const Bool_t *coord=0x0);
void SetMinNtracks(Int_t minNtracks){fmintracks=minNtracks;}
void RealignITStracks(TString minimizer,Int_t fit,Int_t iter1,Int_t iterations,Int_t minNtracks,Int_t layer,Int_t minTrackPoint,Bool_t covUsed,TString misalignmentFile,TString startingfile,Int_t doGlobal);
Bool_t AlignVolumesITS(const TArrayI *volids, const TArrayI *volidsfit,AliGeomManager::ELayerID layerRangeMin,AliGeomManager::ELayerID layerRangeMax,Int_t iterations);
Bool_t FirstAlignmentSPD(Int_t minNtracks,Int_t iterations,Bool_t fitall=kTRUE,TArrayI *volidsSet=0x0);
- Bool_t FirstAlignmentLayers(Bool_t *layers,Int_t minNtracks,Int_t iterations,Bool_t fitall=kTRUE,TArrayI *volidsSet=0x0);
+ Bool_t FirstAlignmentLayers(const Bool_t *layers,Int_t minNtracks,Int_t iterations,Bool_t fitall=kTRUE,TArrayI *volidsSet=0x0);
Bool_t SPDmodulesAlignToSSD(Int_t minNtracks,Int_t iterations);
Bool_t AlignSPDBarrel(Int_t iterations);
Bool_t AlignSPDHalfBarrel(Int_t method,Int_t iterations);
Bool_t AlignLayer(Int_t layer,Int_t iterations);
- Bool_t AlignLayersToLayers(Int_t *layer,Int_t iterations);
+ Bool_t AlignLayersToLayers(const Int_t *layer,Int_t iterations);
Bool_t AlignLayerToSPDHalfBarrel(Int_t layer,Int_t updown,Int_t iterations);
Bool_t AlignLayerToSector(Int_t layer,Int_t sector,Int_t iterations);
Bool_t AlignSPDSectorToOuterLayers(Int_t sector,Int_t iterations);
Bool_t AlignSPDHalfBarrelToSectorRef(Int_t sector,Int_t iterations);
Bool_t AlignSPD1SectorRef(Int_t sector,Int_t iterations);
//masera void AlignGlobalToSectRef(Int_t sector,Int_t minNtracks=100);
- TArrayI* GetLayersVolUID(Int_t *layer);
+ TArrayI* GetLayersVolUID(const Int_t *layer);
AliAlignObjParams* MediateAlignObj(TArrayI *volIDs,Int_t lastVolid);
- TArrayI* GetSPDSectorsVolids(Int_t *sectors);
- TArrayI* GetSPDStavesVolids(Int_t *sectors,Int_t* staves);
+ TArrayI* GetSPDSectorsVolids(const Int_t *sectors);
+ TArrayI* GetSPDStavesVolids(const Int_t *sectors,const Int_t* staves);
TArrayI* SelectLayerInVolids(const TArrayI *volidsIN,AliGeomManager::ELayerID layer);
TArrayI* JoinVolArrays(const TArrayI *vol1,const TArrayI *vol2);
TArrayI* IntersectVolArray(const TArrayI *vol1,const TArrayI *vol2);
TArrayI* ExcludeVolidsFromVolidsArray(const TArrayI *volidsToExclude,const TArrayI *volStart);
- TArrayI* GetLayerVolumes(Int_t *layer);
+ TArrayI* GetLayerVolumes(const Int_t *layer);
TArrayI* GetAlignedVolumes(char *filename);
/* void AlignGlobalToSectRef(Int_t sector,Int_t minNtracks=100);
AliAlignObjParams* MediateAlignObjs(AliAlignObj **alObjs,Int_t nObjs,const Bool_t *coords=0x0,TArrayI *volidArray=0x0,Bool_t local=kFALSE,const char* geometryfile=0x0);
AliAlignObj ***fSurveyObjs; // Array with survey measurments
TString fgeomfilename; // Geometry file name
Int_t fmintracks; // minimum number of tracks to realign a set of volumes
- Bool_t fCovIsUsed; // indicates wheter AlignObj's cov. matrix is used in loading the points
Bool_t fUpdateCov; // Update of Covariance for AlignObjs
Bool_t fVarySigmaY; // If kTRUE the "sigmaY" parameter is changed accordingly to alignObj error
Double_t **fCorrModules; // Used to reduce correlations between modules
#include <TMatrixD.h>
#include <TTree.h>
-#include <TTreeStream.h>
#include <TDatabasePDG.h>
#include <TString.h>
#include <TRandom.h>
+#include <TTreeStream.h>
#include "AliLog.h"
+#include "AliITSPlaneEff.h"
+#include "AliITSCalibrationSPD.h"
+#include "AliITSCalibrationSDD.h"
+#include "AliITSCalibrationSSD.h"
+#include "AliCDBEntry.h"
+#include "AliCDBManager.h"
+#include "AliAlignObj.h"
+#include "AliTrackPointArray.h"
+#include "AliESDVertex.h"
#include "AliESDEvent.h"
#include "AliESDtrack.h"
-#include "AliESDVertex.h"
#include "AliV0.h"
#include "AliHelix.h"
+#include "AliITSChannelStatus.h"
+#include "AliITSDetTypeRec.h"
#include "AliITSRecPoint.h"
#include "AliITSgeomTGeo.h"
#include "AliITSReconstructor.h"
-#include "AliTrackPointArray.h"
-#include "AliAlignObj.h"
#include "AliITSClusterParam.h"
-#include "AliCDBManager.h"
-#include "AliCDBEntry.h"
#include "AliITSsegmentation.h"
#include "AliITSCalibration.h"
-#include "AliITSCalibrationSPD.h"
-#include "AliITSCalibrationSDD.h"
-#include "AliITSCalibrationSSD.h"
-#include "AliITSPlaneEff.h"
#include "AliITSPlaneEffSPD.h"
#include "AliITSPlaneEffSDD.h"
#include "AliITSPlaneEffSSD.h"
fxTimesRhoLayerTrks(0),
fDebugStreamer(0),
fITSChannelStatus(0),
-fDetTypeRec(0),
+fkDetTypeRec(0),
fPlaneEff(0) {
//Default constructor
Int_t i;
fxTimesRhoLayerTrks(0),
fDebugStreamer(0),
fITSChannelStatus(0),
-fDetTypeRec(0),
+fkDetTypeRec(0),
fPlaneEff(0) {
//--------------------------------------------------------------------
//This is the AliITStrackerMI constructor
fxTimesRhoLayerTrks(0),
fDebugStreamer(tracker.fDebugStreamer),
fITSChannelStatus(tracker.fITSChannelStatus),
-fDetTypeRec(tracker.fDetTypeRec),
+fkDetTypeRec(tracker.fkDetTypeRec),
fPlaneEff(tracker.fPlaneEff) {
//Copy constructor
Int_t i;
if(fPlaneEff) delete fPlaneEff;
}
//------------------------------------------------------------------------
-void AliITStrackerMI::SetLayersNotToSkip(Int_t *l) {
+void AliITStrackerMI::SetLayersNotToSkip(const Int_t *l) {
//--------------------------------------------------------------------
//This function set masks of the layers which must be not skipped
//--------------------------------------------------------------------
Info("ReadBadFromDetTypeRec","Reading info about bad ITS detectors and channels");
- if(!fDetTypeRec) Error("ReadBadFromDetTypeRec","AliITSDetTypeRec nof found!\n");
+ if(!fkDetTypeRec) Error("ReadBadFromDetTypeRec","AliITSDetTypeRec nof found!\n");
// ITS channels map
if(fITSChannelStatus) delete fITSChannelStatus;
- fITSChannelStatus = new AliITSChannelStatus(fDetTypeRec);
+ fITSChannelStatus = new AliITSChannelStatus(fkDetTypeRec);
// ITS detectors and chips
Int_t i=0,j=0,k=0,ndet=0;
for (j=1; j<AliITSgeomTGeo::GetNLadders(i)+1; j++) {
for (k=1; k<ndet+1; k++) {
AliITSdetector &det=fgLayers[i-1].GetDetector((j-1)*ndet + k-1);
- det.ReadBadDetectorAndChips(i-1,(j-1)*ndet + k-1,fDetTypeRec);
+ det.ReadBadDetectorAndChips(i-1,(j-1)*ndet + k-1,fkDetTypeRec);
if(det.IsBad()) {nBadDetsPerLayer++;}
} // end loop on detectors
} // end loop on ladders
}
//------------------------------------------------------------------------
void AliITStrackerMI::AliITSdetector::ReadBadDetectorAndChips(Int_t ilayer,Int_t idet,
- AliITSDetTypeRec *detTypeRec)
+ const AliITSDetTypeRec *detTypeRec)
{
//--------------------------------------------------------------------
// Read bad detectors and chips from calibration objects in AliITSDetTypeRec
return normchi2;
}
//------------------------------------------------------------------------
-Double_t AliITStrackerMI::GetMatchingChi2(AliITStrackMI * track1, AliITStrackMI * track2)
+Double_t AliITStrackerMI::GetMatchingChi2(const AliITStrackMI * track1,const AliITStrackMI * track2)
{
//
// return matching chi2 between two tracks
return chi2(0,0);
}
//------------------------------------------------------------------------
-Double_t AliITStrackerMI::GetSPDDeadZoneProbability(Double_t zpos, Double_t zerr)
+Double_t AliITStrackerMI::GetSPDDeadZoneProbability(Double_t zpos, Double_t zerr) const
{
//
// return probability that given point (characterized by z position and error)
return probability;
}
//------------------------------------------------------------------------
-Double_t AliITStrackerMI::GetTruncatedChi2(AliITStrackMI * track, Float_t fac)
+Double_t AliITStrackerMI::GetTruncatedChi2(const AliITStrackMI * track, Float_t fac)
{
//
// calculate normalized chi2
return normchi2;
}
//------------------------------------------------------------------------
-Double_t AliITStrackerMI::GetInterpolatedChi2(AliITStrackMI * forwardtrack, AliITStrackMI * backtrack)
+Double_t AliITStrackerMI::GetInterpolatedChi2(const AliITStrackMI * forwardtrack,const AliITStrackMI * backtrack)
{
//
// calculate normalized chi2
return fgLayers[l].GetWeight(c);
}
//------------------------------------------------------------------------
-void AliITStrackerMI::RegisterClusterTracks(AliITStrackMI* track,Int_t id)
+void AliITStrackerMI::RegisterClusterTracks(const AliITStrackMI* track,Int_t id)
{
//---------------------------------------------
// register track to the list
}
}
//------------------------------------------------------------------------
-void AliITStrackerMI::UnRegisterClusterTracks(AliITStrackMI* track, Int_t id)
+void AliITStrackerMI::UnRegisterClusterTracks(const AliITStrackMI* track, Int_t id)
{
//---------------------------------------------
// unregister track from the list
return shared;
}
//------------------------------------------------------------------------
-Int_t AliITStrackerMI::GetOverlapTrack(AliITStrackMI *track, Int_t trackID, Int_t &shared, Int_t clusterlist[6],Int_t overlist[6])
+Int_t AliITStrackerMI::GetOverlapTrack(const AliITStrackMI *track, Int_t trackID, Int_t &shared, Int_t clusterlist[6],Int_t overlist[6])
{
//
// find first shared track
//------------------------------------------------------------------------
void AliITStrackerMI::MakeCoefficients(Int_t ntracks){
//
+ // Create some arrays
//
if (fCoefficients) delete []fCoefficients;
fCoefficients = new Float_t[ntracks*48];
Double_t AliITStrackerMI::GetPredictedChi2MI(AliITStrackMI* track, const AliITSRecPoint *cluster,Int_t layer)
{
//
- //
+ // Compute predicted chi2
//
Float_t erry,errz;
Float_t theta = track->GetTgl();
Int_t AliITStrackerMI::UpdateMI(AliITStrackMI* track, const AliITSRecPoint* cl,Double_t chi2,Int_t index) const
{
//
- //
+ // Update ITS track
//
Int_t layer = (index & 0xf0000000) >> 28;
track->SetClIndex(layer, index);
}
//------------------------------------------------------------------------
-void AliITStrackerMI::GetDCASigma(AliITStrackMI* track, Float_t & sigmarfi, Float_t &sigmaz)
+void AliITStrackerMI::GetDCASigma(const AliITStrackMI* track, Float_t & sigmarfi, Float_t &sigmaz)
{
//
//DCA sigmas parameterization
sigmaz = 0.0110+4.37*TMath::Abs(track->GetC());
}
//------------------------------------------------------------------------
-void AliITStrackerMI::SignDeltas( TObjArray *ClusterArray, Float_t vz)
+void AliITStrackerMI::SignDeltas(const TObjArray *clusterArray, Float_t vz)
{
//
+ // Clusters from delta electrons?
//
- Int_t entries = ClusterArray->GetEntriesFast();
+ Int_t entries = clusterArray->GetEntriesFast();
if (entries<4) return;
- AliITSRecPoint* cluster = (AliITSRecPoint*)ClusterArray->At(0);
+ AliITSRecPoint* cluster = (AliITSRecPoint*)clusterArray->At(0);
Int_t layer = cluster->GetLayer();
if (layer>1) return;
Int_t index[10000];
Float_t r = (layer>0)? 7:4;
//
for (Int_t i=0;i<entries;i++){
- AliITSRecPoint* cl0 = (AliITSRecPoint*)ClusterArray->At(i);
+ AliITSRecPoint* cl0 = (AliITSRecPoint*)clusterArray->At(i);
Float_t nz = 1+TMath::Abs((cl0->GetZ()-vz)/r);
if (cl0->GetNy()+cl0->GetNz()<=5+2*layer+nz) continue;
index[ncandidates] = i; //candidate to belong to delta electron track
//
//
for (Int_t i=0;i<ncandidates;i++){
- AliITSRecPoint* cl0 = (AliITSRecPoint*)ClusterArray->At(index[i]);
+ AliITSRecPoint* cl0 = (AliITSRecPoint*)clusterArray->At(index[i]);
if (cl0->GetDeltaProbability()>0.8) continue;
//
Int_t ncl = 0;
sumy=sumz=sumy2=sumyz=sumw=0.0;
for (Int_t j=0;j<ncandidates;j++){
if (i==j) continue;
- AliITSRecPoint* cl1 = (AliITSRecPoint*)ClusterArray->At(index[j]);
+ AliITSRecPoint* cl1 = (AliITSRecPoint*)clusterArray->At(index[j]);
//
Float_t dz = cl0->GetZ()-cl1->GetZ();
Float_t dy = cl0->GetY()-cl1->GetY();
void AliITStrackerMI::UpdateESDtrack(AliITStrackMI* track, ULong_t flags) const
{
//
+ // Update ESD track
//
track->UpdateESDtrack(flags);
AliITStrackMI * oldtrack = (AliITStrackMI*)(track->GetESDtrack()->GetITStrack());
return res;
}
//------------------------------------------------------------------------
-void AliITStrackerMI::UpdateTPCV0(AliESDEvent *event){
+void AliITStrackerMI::UpdateTPCV0(const AliESDEvent *event){
//
//try to update, or reject TPC V0s
//
delete pvertex;
}
//------------------------------------------------------------------------
-void AliITStrackerMI::RefitV02(AliESDEvent *event)
+void AliITStrackerMI::RefitV02(const AliESDEvent *event)
{
//
//try to refit V0s in the third path of the reconstruction
return;
}
//------------------------------------------------------------------------
-Int_t AliITStrackerMI::CheckSkipLayer(AliITStrackMI *track,
+Int_t AliITStrackerMI::CheckSkipLayer(const AliITStrackMI *track,
Int_t ilayer,Int_t idet) const {
//-----------------------------------------------------------------
// This method is used to decide whether to allow a prolongation
} else if (ilayer==4 || ilayer==5) { // ---------- SSD
detType = 2;
}
- AliITSsegmentation *segm = (AliITSsegmentation*)fDetTypeRec->GetSegmentationModel(detType);
+ AliITSsegmentation *segm = (AliITSsegmentation*)fkDetTypeRec->GetSegmentationModel(detType);
if (detType==2) segm->SetLayer(ilayer+1);
Float_t detSizeX = detSizeFactorX*segm->Dx();
Float_t detSizeZ = detSizeFactorZ*segm->Dz();
}
//------------------------------------------------------------------------
Bool_t AliITStrackerMI::LocalModuleCoord(Int_t ilayer,Int_t idet,
- AliITStrackMI *track,
+ const AliITStrackMI *track,
Float_t &xloc,Float_t &zloc) const {
//-----------------------------------------------------------------
// Gives position of track in local module ref. frame
return kTRUE;
}
//------------------------------------------------------------------------
-Bool_t AliITStrackerMI::IsOKForPlaneEff(AliITStrackMI* track, const Int_t *clusters, Int_t ilayer) const {
+Bool_t AliITStrackerMI::IsOKForPlaneEff(const AliITStrackMI* track, const Int_t *clusters, Int_t ilayer) const {
//
// Method to be optimized further:
// Aim: decide whether a track can be used for PlaneEff evaluation
return kTRUE;
}
//------------------------------------------------------------------------
-void AliITStrackerMI::UseTrackForPlaneEff(AliITStrackMI* track, Int_t ilayer) {
+void AliITStrackerMI::UseTrackForPlaneEff(const AliITStrackMI* track, Int_t ilayer) {
//
// This Method has to be optimized! For the time-being it uses the same criteria
// as those used in the search of extra clusters for overlapping modules.
class TTreeSRedirector;
class AliESDEvent;
+class AliITSPlaneEff;
+class AliITSChannelStatus;
+class AliITSDetTypeRec;
+class AliPlaneEff;
+
#include <TObjArray.h>
-#include "AliITSRecPoint.h"
+
#include "AliITStrackMI.h"
-#include "AliITSPlaneEff.h"
-#include "AliITSChannelStatus.h"
-#include "AliITSDetTypeRec.h"
-#include "AliPlaneEff.h"
+#include "AliITSRecPoint.h"
#include "AliTracker.h"
+
//-------------------------------------------------------------------------
class AliITStrackerMI : public AliTracker {
public:
const AliITStrackMI *clusters, Bool_t extra=kFALSE, Bool_t planeeff=kFALSE);
Bool_t RefitAt(Double_t x, AliITStrackMI *track,
const Int_t *clusters, Bool_t extra=kFALSE, Bool_t planeeff=kFALSE);
- void SetupFirstPass(Int_t *flags, Double_t *cuts=0);
- void SetupSecondPass(Int_t *flags, Double_t *cuts=0);
+ void SetupFirstPass(const Int_t *flags,const Double_t *cuts=0);
+ void SetupSecondPass(const Int_t *flags,const Double_t *cuts=0);
void SetLastLayerToTrackTo(Int_t l=0) {fLastLayerToTrackTo=l;}
- void SetLayersNotToSkip(Int_t *l);
+ void SetLayersNotToSkip(const Int_t *l);
void UseClusters(const AliKalmanTrack *t, Int_t from=0) const;
- void GetDCASigma(AliITStrackMI* track, Float_t & sigmarfi, Float_t &sigmaz);
+ void GetDCASigma(const AliITStrackMI* track, Float_t & sigmarfi, Float_t &sigmaz);
Double_t GetPredictedChi2MI(AliITStrackMI* track, const AliITSRecPoint *cluster,Int_t layer);
Int_t UpdateMI(AliITStrackMI* track, const AliITSRecPoint* cl,Double_t chi2,Int_t layer) const;
AliPlaneEff *GetPlaneEff() {return (AliPlaneEff*)fPlaneEff;} // return the pointer to AliPlaneEff
- void SetDetTypeRec(AliITSDetTypeRec *detTypeRec) {fDetTypeRec = detTypeRec; ReadBadFromDetTypeRec(); }
+ void SetDetTypeRec(const AliITSDetTypeRec *detTypeRec) {fkDetTypeRec = detTypeRec; ReadBadFromDetTypeRec(); }
class AliITSdetector {
public:
void SetZmin(Double_t min) {fZmin = min;}
void SetZmax(Double_t max) {fZmax = max;}
void SetBad() {fIsBad = kTRUE;}
- void ReadBadDetectorAndChips(Int_t ilayer,Int_t idet,AliITSDetTypeRec *detTypeRec);
+ void ReadBadDetectorAndChips(Int_t ilayer,Int_t idet,const AliITSDetTypeRec *detTypeRec);
private:
AliITSdetector(const AliITSdetector& det);
AliITSdetector & operator=(const AliITSdetector& det){
Double_t GetR() const {return fR;}
Int_t FindClusterIndex(Float_t z) const;
AliITSRecPoint *GetCluster(Int_t i) const {return i<fN? fClusters[i]:0;}
- Float_t *GetWeight(Int_t i) {return i<fN ?&fClusterWeight[i]:0;}
+ Float_t *GetWeight(Int_t i) {return i<fN ?&fClusterWeight[i]:0;}
AliITSdetector &GetDetector(Int_t n) const { return fDetectors[n]; }
Int_t FindDetectorIndex(Double_t phi, Double_t z) const;
Double_t GetThickness(Double_t y, Double_t z, Double_t &x0) const;
Bool_t ComputeRoad(AliITStrackMI* track,Int_t ilayer,Int_t idet,Double_t &zmin,Double_t &zmax,Double_t &ymin,Double_t &ymax) const;
Int_t GetNearestLayer(const Double_t *xr) const; //get nearest upper layer close to the point xr
void FindV02(AliESDEvent *event); //try to find V0
- void RefitV02(AliESDEvent *event); //try to refit V0's
- void UpdateTPCV0(AliESDEvent *event); //try to update, or reject TPC V0s
+ void RefitV02(const AliESDEvent *event); //try to refit V0's
+ void UpdateTPCV0(const AliESDEvent *event); //try to update, or reject TPC V0s
void CookLabel(AliKalmanTrack *t,Float_t wrong) const;
void CookLabel(AliITStrackMI *t,Float_t wrong) const;
Double_t GetEffectiveThickness();
}
void CookdEdx(AliITStrackMI* track);
Double_t GetNormalizedChi2(AliITStrackMI * track, Int_t mode);
- Double_t GetTruncatedChi2(AliITStrackMI * track, Float_t fac);
+ Double_t GetTruncatedChi2(const AliITStrackMI * track, Float_t fac);
Double_t NormalizedChi2(AliITStrackMI * track, Int_t layer);
- Double_t GetInterpolatedChi2(AliITStrackMI * forwardtrack, AliITStrackMI * backtrack);
- Double_t GetMatchingChi2(AliITStrackMI * track1, AliITStrackMI * track2);
- Double_t GetSPDDeadZoneProbability(Double_t zpos, Double_t zerr);
+ Double_t GetInterpolatedChi2(const AliITStrackMI * forwardtrack,const AliITStrackMI * backtrack);
+ Double_t GetMatchingChi2(const AliITStrackMI * track1,const AliITStrackMI * track2);
+ Double_t GetSPDDeadZoneProbability(Double_t zpos, Double_t zerr) const;
Float_t *GetWeight(Int_t index);
void AddTrackHypothesys(AliITStrackMI * track, Int_t esdindex);
void SortTrackHypothesys(Int_t esdindex, Int_t maxcut, Int_t mode);
AliITStrackMI * GetBestHypothesys(Int_t esdindex, AliITStrackMI * original, Int_t checkmax);
void GetBestHypothesysMIP(TObjArray &itsTracks);
- void RegisterClusterTracks(AliITStrackMI* track, Int_t id);
- void UnRegisterClusterTracks(AliITStrackMI* track, Int_t id);
+ void RegisterClusterTracks(const AliITStrackMI* track, Int_t id);
+ void UnRegisterClusterTracks(const AliITStrackMI* track, Int_t id);
Float_t GetNumberOfSharedClusters(AliITStrackMI* track,Int_t id, Int_t list[6], AliITSRecPoint *clist[6]);
- Int_t GetOverlapTrack(AliITStrackMI *track, Int_t trackID, Int_t &shared, Int_t clusterlist[6], Int_t overlist[6]);
+ Int_t GetOverlapTrack(const AliITStrackMI *track, Int_t trackID, Int_t &shared, Int_t clusterlist[6], Int_t overlist[6]);
AliITStrackMI * GetBest2Tracks(Int_t trackID1, Int_t treackID2, Float_t th0, Float_t th1);
Float_t * GetErrY(Int_t trackindex) const {return &fCoefficients[trackindex*48];}
Float_t * GetErrZ(Int_t trackindex) const {return &fCoefficients[trackindex*48+12];}
Float_t * GetNy(Int_t trackindex) const {return &fCoefficients[trackindex*48+24];}
Float_t * GetNz(Int_t trackindex) const {return &fCoefficients[trackindex*48+36];}
- void SignDeltas( TObjArray *ClusterArray, Float_t zv);
+ void SignDeltas(const TObjArray *clusterArray, Float_t zv);
void MakeCoefficients(Int_t ntracks);
void BuildMaterialLUT(TString material);
void MakeTrksMaterialLUT(Int_t ntracks);
Int_t CorrectForLayerMaterial(AliITStrackMI *t, Int_t layerindex, Double_t oldGlobXYZ[3], TString direction="inward");
void UpdateESDtrack(AliITStrackMI* track, ULong_t flags) const;
void ReadBadFromDetTypeRec();
- Int_t CheckSkipLayer(AliITStrackMI *track,Int_t ilayer,Int_t idet) const;
+ Int_t CheckSkipLayer(const AliITStrackMI *track,Int_t ilayer,Int_t idet) const;
Int_t CheckDeadZone(AliITStrackMI *track,Int_t ilayer,Int_t idet,Double_t dz,Double_t dy,Bool_t noClusters=kFALSE) const;
- Bool_t LocalModuleCoord(Int_t ilayer,Int_t idet,AliITStrackMI *track,
+ Bool_t LocalModuleCoord(Int_t ilayer,Int_t idet,const AliITStrackMI *track,
Float_t &xloc,Float_t &zloc) const;
// method to be used for Plane Efficiency evaluation
- Bool_t IsOKForPlaneEff(AliITStrackMI* track, const Int_t *clusters, Int_t ilayer) const; // Check if a track is usable
+ Bool_t IsOKForPlaneEff(const AliITStrackMI* track, const Int_t *clusters, Int_t ilayer) const; // Check if a track is usable
// for Plane Eff evaluation
- void UseTrackForPlaneEff(AliITStrackMI* track, Int_t ilayer); // Use this track for Plane Eff
+ void UseTrackForPlaneEff(const AliITStrackMI* track, Int_t ilayer); // Use this track for Plane Eff
//
Int_t fI; // index of the current layer
static AliITSlayer fgLayers[AliITSgeomTGeo::kNLayers];// ITS layers
Float_t *fxTimesRhoLayerTrks; //! material budget
TTreeSRedirector *fDebugStreamer; //!debug streamer
AliITSChannelStatus *fITSChannelStatus;//! bitmaps with channel status for SPD and SDD
- AliITSDetTypeRec *fDetTypeRec; //! ITS det type rec, from AliITSReconstructor
+ const AliITSDetTypeRec *fkDetTypeRec; //! ITS det type rec, from AliITSReconstructor
AliITSPlaneEff *fPlaneEff; //! Pointer to the ITS plane efficicency
private:
AliITStrackerMI(const AliITStrackerMI &tracker);
AliITStrackerMI & operator=(const AliITStrackerMI &tracker);
- ClassDef(AliITStrackerMI,6) //ITS tracker MI
+ ClassDef(AliITStrackerMI,7) //ITS tracker MI
};
-inline void AliITStrackerMI::SetupFirstPass(Int_t *flags, Double_t *cuts) {
+inline void AliITStrackerMI::SetupFirstPass(const Int_t *flags,const Double_t *cuts) {
// This function sets up flags and cuts for the first tracking pass
//
// flags[0] - vertex constaint flag
if (cuts==0) return;
}
-inline void AliITStrackerMI::SetupSecondPass(Int_t *flags, Double_t *cuts) {
+inline void AliITStrackerMI::SetupSecondPass(const Int_t *flags,const Double_t *cuts) {
// This function sets up flags and cuts for the second tracking pass
//
// flags[0] - vertex constaint flag
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff