From 443471605587e27178c2c3df8e2125f7f48874ab Mon Sep 17 00:00:00 2001 From: masera Date: Wed, 6 Jun 2007 16:01:24 +0000 Subject: [PATCH] New class AliITSRecoParam. It replaces AliITSRecoV2 (A.Dainese) --- ITS/AliITSRecoParam.cxx | 161 ++++++++++++++ ITS/AliITSRecoParam.h | 118 ++++++++++ ITS/AliITSReconstructor.cxx | 10 +- ITS/AliITSReconstructor.h | 5 + ITS/AliITSclusterV2.h | 2 +- ITS/AliITSrecoV2.h | 57 ----- ITS/AliITStrackMI.h | 2 +- ITS/AliITStrackV2.h | 2 +- ITS/AliITStrackerMI.cxx | 423 ++++++++++++++++++------------------ ITS/AliITStrackerV2.cxx | 50 +++-- ITS/AliITStrackerV2.h | 2 +- ITS/ITSrecLinkDef.h | 1 + ITS/libITSrec.pkg | 3 +- 13 files changed, 541 insertions(+), 295 deletions(-) create mode 100644 ITS/AliITSRecoParam.cxx create mode 100644 ITS/AliITSRecoParam.h delete mode 100644 ITS/AliITSrecoV2.h diff --git a/ITS/AliITSRecoParam.cxx b/ITS/AliITSRecoParam.cxx new file mode 100644 index 00000000000..193722e4594 --- /dev/null +++ b/ITS/AliITSRecoParam.cxx @@ -0,0 +1,161 @@ +/************************************************************************** + * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. * + * * + * Author: The ALICE Off-line Project. * + * Contributors are mentioned in the code where appropriate. * + * * + * Permission to use, copy, modify and distribute this software and its * + * documentation strictly for non-commercial purposes is hereby granted * + * without fee, provided that the above copyright notice appears in all * + * copies and that both the copyright notice and this permission notice * + * appear in the supporting documentation. The authors make no claims * + * about the suitability of this software for any purpose. It is * + * provided "as is" without express or implied warranty. * + **************************************************************************/ + + +/////////////////////////////////////////////////////////////////////////////// +// // +// Class with ITS reconstruction parameters // +// Origin: andrea.dainese@lnl.infn.it // +// // +/////////////////////////////////////////////////////////////////////////////// + + +#include "AliITSRecoParam.h" + +ClassImp(AliITSRecoParam) + + +//_____________________________________________________________________________ +AliITSRecoParam::AliITSRecoParam() +{ + // + // constructor + // + SetLayersParameters(); +} +//_____________________________________________________________________________ +AliITSRecoParam::~AliITSRecoParam() +{ + // + // destructor + // +} +//_____________________________________________________________________________ +AliITSRecoParam *AliITSRecoParam::GetHighFluxParam() +{ + // + // make default reconstruction parameters for hig flux env. + // + AliITSRecoParam *param = new AliITSRecoParam(); + + param->fMaxSnp = 0.95; + + param->fNSigmaYLayerForRoadY = 4.; + param->fNSigmaRoadY = 7.5; + param->fNSigmaZLayerForRoadZ = 4.; + param->fNSigmaRoadZ = 7.5; + + param->fNSigma2RoadZC = 60.; //7.75^2 + param->fNSigma2RoadYC = 60.; //7.75^2 + param->fNSigma2RoadZNonC = 50.; //7.07^2 + param->fNSigma2RoadYNonC = 50.; //7.07^2 + + param->fMaxChi2PerCluster[0] = 11.; //7 + param->fMaxChi2PerCluster[1] = 12.; //5 + param->fMaxChi2PerCluster[2] = 12.; //8 + param->fMaxChi2PerCluster[3] = 5.; //8 + param->fMaxChi2PerCluster[4] = 12.; //6.5 + + param->fMaxNormChi2NonC[0] = 7.; + param->fMaxNormChi2NonC[1] = 8.; + param->fMaxNormChi2NonC[2] = 8.; + param->fMaxNormChi2NonC[3] = 11.; + param->fMaxNormChi2NonC[4] = 14.; + param->fMaxNormChi2NonC[5] = 25.; + + param->fMaxNormChi2C[0] = 11.; + param->fMaxNormChi2C[1] = 13.; + param->fMaxNormChi2C[2] = 15.; + param->fMaxNormChi2C[3] = 18.; + param->fMaxNormChi2C[4] = 30.; + param->fMaxNormChi2C[5] = 35.; + + param->fMaxChi2 = 35.; + + param->fMaxChi2s[0] = 25.; //40 + param->fMaxChi2s[1] = 25.; //40 + param->fMaxChi2s[2] = 25.; //40 + param->fMaxChi2s[3] = 25.; //40 + param->fMaxChi2s[4] = 40.; //40 + param->fMaxChi2s[5] = 50.; //40 + + param->fMaxRoad = 6.; + + // not used + param->fMaxChi2In = 16.; + + param->fMaxChi2sR[0] = 10.; + param->fMaxChi2sR[1] = 10.; + param->fMaxChi2sR[2] = 10.; + param->fMaxChi2sR[3] = 10.; + param->fMaxChi2sR[4] = 30.; + param->fMaxChi2sR[5] = 40.; + + param->fChi2PerCluster = 9.; + // not used + + param->fXV = 0.; + param->fYV = 0.; + param->fZV = 0.; + param->fSigmaXV = 0.0050; + param->fSigmaYV = 0.0050; + param->fSigmaZV = 0.0100; + + param->fVertexCut = 25.; + + return param; +} +//_____________________________________________________________________________ +AliITSRecoParam *AliITSRecoParam::GetLowFluxParam() +{ + // + // make default reconstruction parameters for low flux env. + // + return GetHighFluxParam(); +} +//_____________________________________________________________________________ +AliITSRecoParam *AliITSRecoParam::GetCosmicTestParam() +{ + // + // make default reconstruction parameters for cosmics + // + return GetHighFluxParam(); +} +//_____________________________________________________________________________ +void AliITSRecoParam::SetLayersParameters() +{ + // + // number of layers and layers spatial resolutions + // + + // spatial resolutions of the detectors + // y: 12 12 38 38 20 20 micron + fSigmaY2[0]=1.44e-6; + fSigmaY2[1]=1.44e-6; + fSigmaY2[2]=1.444e-5; + fSigmaY2[3]=1.444e-5; + fSigmaY2[4]=4.0e-6; + fSigmaY2[5]=4.0e-6; + // z: 120 120 28 28 830 830 micron + fSigmaZ2[0]=1.44e-4; + fSigmaZ2[1]=1.44e-4; + fSigmaZ2[2]=7.84e-6; + fSigmaZ2[3]=7.84e-6; + fSigmaZ2[4]=6.889e-3; + fSigmaZ2[5]=6.889e-3; + + return; +} + diff --git a/ITS/AliITSRecoParam.h b/ITS/AliITSRecoParam.h new file mode 100644 index 00000000000..4855e684b51 --- /dev/null +++ b/ITS/AliITSRecoParam.h @@ -0,0 +1,118 @@ +#ifndef ALIITSRECOPARAM_H +#define ALIITSRECOPARAM_H +/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +/////////////////////////////////////////////////////////////////////////////// +// // +// Class with ITS reconstruction parameters // +// Origin: andrea.dainese@lnl.infn.it // +// // +/////////////////////////////////////////////////////////////////////////////// + + +#include "TObject.h" + +//--------------- move from AliITSrecoV2.h --------------------------- +const Int_t kMaxLayer = 6; + +const Int_t kLayersNotToSkip[6]={0,0,0,0,0,0}; +const Int_t kLastLayerToTrackTo=0; + +const Int_t kMaxClusterPerLayer=7000*10; +const Int_t kMaxClusterPerLayer5=7000*10*2/5; +const Int_t kMaxClusterPerLayer10=7000*10*2/10; +const Int_t kMaxClusterPerLayer20=7000*10*2/20; +const Int_t kMaxDetectorPerLayer=1000; +//------------- end of move from AliITSrecoV2.h -------------------- + + +class AliITSRecoParam : public TObject +{ + public: + AliITSRecoParam(); + virtual ~AliITSRecoParam(); + + static AliITSRecoParam *GetLowFluxParam();// make reco parameters for low flux env. + static AliITSRecoParam *GetHighFluxParam();// make reco parameters for high flux env. + static AliITSRecoParam *GetCosmicTestParam();// special setting for cosmic + + + Double_t GetSigmaY2(Int_t i) const { return fSigmaY2[i]; } + Double_t GetSigmaZ2(Int_t i) const { return fSigmaZ2[i]; } + + Double_t GetMaxSnp() const { return fMaxSnp; } + + Double_t GetNSigmaYLayerForRoadY() const { return fNSigmaYLayerForRoadY; } + Double_t GetNSigmaRoadY() const { return fNSigmaRoadY; } + Double_t GetNSigmaZLayerForRoadZ() const { return fNSigmaZLayerForRoadZ; } + Double_t GetNSigmaRoadZ() const { return fNSigmaRoadZ; } + Double_t GetNSigma2RoadYC() const { return fNSigma2RoadYC; } + Double_t GetNSigma2RoadZC() const { return fNSigma2RoadZC; } + Double_t GetNSigma2RoadYNonC() const { return fNSigma2RoadYNonC; } + Double_t GetNSigma2RoadZNonC() const { return fNSigma2RoadZNonC; } + + Double_t GetChi2PerCluster() const { return fChi2PerCluster; } + Double_t GetMaxChi2PerCluster(Int_t i) const { return fMaxChi2PerCluster[i]; } + Double_t GetMaxNormChi2NonC(Int_t i) const { return fMaxNormChi2NonC[i]; } + Double_t GetMaxNormChi2C(Int_t i) const { return fMaxNormChi2C[i]; } + Double_t GetMaxChi2() const { return fMaxChi2; } + Double_t GetMaxChi2s(Int_t i) const { return fMaxChi2s[i]; } + Double_t GetMaxChi2sR(Int_t i) const { return fMaxChi2sR[i]; } + Double_t GetMaxChi2In() const { return fMaxChi2In; } + Double_t GetVertexCut() const { return fVertexCut; } + Double_t GetMaxRoad() const { return fMaxRoad; } + + Double_t GetXVdef() const { return fXV; } + Double_t GetYVdef() const { return fYV; } + Double_t GetZVdef() const { return fZV; } + Double_t GetSigmaXVdef() const { return fSigmaXV; } + Double_t GetSigmaYVdef() const { return fSigmaYV; } + Double_t GetSigmaZVdef() const { return fSigmaZV; } + + void SetLayersParameters(); + // + protected: + // + // spatial resolutions of the detectors + Double_t fSigmaY2[kMaxLayer]; + Double_t fSigmaZ2[kMaxLayer]; + // + Double_t fMaxSnp; // maximum of sin(phi) (MI) + // + // search road (MI) + Double_t fNSigmaYLayerForRoadY; + Double_t fNSigmaRoadY; + Double_t fNSigmaZLayerForRoadZ; + Double_t fNSigmaRoadZ; + Double_t fNSigma2RoadZC; + Double_t fNSigma2RoadYC; + Double_t fNSigma2RoadZNonC; + Double_t fNSigma2RoadYNonC; + // + // chi2 cuts + Double_t fMaxChi2PerCluster[kMaxLayer-1]; // max chi2 for MIP (MI) + Double_t fMaxNormChi2NonC[kMaxLayer]; //max norm chi2 for non constrained tracks (MI) + Double_t fMaxNormChi2C[kMaxLayer]; //max norm chi2 for constrained tracks (MI) + Double_t fMaxChi2; // used to initialize variables needed to find minimum chi2 (MI,V2) + Double_t fMaxChi2s[kMaxLayer]; // max predicted chi2 (cluster & track prol.) (MI) + // + Double_t fMaxRoad; // (V2) + // + Double_t fMaxChi2In; // (NOT USED) + Double_t fMaxChi2sR[kMaxLayer]; // (NOT USED) + Double_t fChi2PerCluster; // (NOT USED) + // + // default primary vertex (MI,V2) + Double_t fXV; + Double_t fYV; + Double_t fZV; + Double_t fSigmaXV; + Double_t fSigmaYV; + Double_t fSigmaZV; + Double_t fVertexCut; // (V2) + // + ClassDef(AliITSRecoParam,1) // ITS reco parameters +}; + +#endif diff --git a/ITS/AliITSReconstructor.cxx b/ITS/AliITSReconstructor.cxx index 996753107a2..32d2e62bf78 100644 --- a/ITS/AliITSReconstructor.cxx +++ b/ITS/AliITSReconstructor.cxx @@ -42,22 +42,30 @@ #include "AliITSpidESD2.h" #include "AliITSInitGeometry.h" + ClassImp(AliITSReconstructor) +AliITSRecoParam *AliITSReconstructor::fgkRecoParam =0; // reconstruction parameters + //___________________________________________________________________________ AliITSReconstructor::AliITSReconstructor() : AliReconstructor(), fItsPID(0) { // Default constructor + if (!fgkRecoParam) { + AliError("The Reconstruction parameters nonitialized - Used default one"); + fgkRecoParam = AliITSRecoParam::GetHighFluxParam(); + } } //___________________________________________________________________________ AliITSReconstructor::~AliITSReconstructor(){ // destructor delete fItsPID; + if(fgkRecoParam) delete fgkRecoParam; } //______________________________________________________________________ AliITSReconstructor::AliITSReconstructor(const AliITSReconstructor &ob) :AliReconstructor(ob), -fItsPID(ob.fItsPID) + fItsPID(ob.fItsPID) { // Copy constructor } diff --git a/ITS/AliITSReconstructor.h b/ITS/AliITSReconstructor.h index 814f74aa96b..a216a8a2253 100644 --- a/ITS/AliITSReconstructor.h +++ b/ITS/AliITSReconstructor.h @@ -11,6 +11,7 @@ /////////////////////////////////////////////////////////////////////////////// #include "AliReconstructor.h" +#include "AliITSRecoParam.h" class AliITSgeom; class AliLoader; @@ -48,10 +49,14 @@ public: AliRawReader* rawReader, AliESD* esd) const {AliReconstructor::FillESD(runLoader,rawReader, esd);} + void SetRecoParam(AliITSRecoParam * param){ fgkRecoParam = param;} + static const AliITSRecoParam* GetRecoParam(){ return fgkRecoParam;} + private: // methods AliITSgeom* GetITSgeom(AliRunLoader* runLoader) const; //data + static AliITSRecoParam * fgkRecoParam; // reconstruction parameters AliITSpidESD *fItsPID; //Pid for ITS ClassDef(AliITSReconstructor, 1) // class for the ITS reconstruction }; diff --git a/ITS/AliITSclusterV2.h b/ITS/AliITSclusterV2.h index bfd56720779..c97d663bf9f 100644 --- a/ITS/AliITSclusterV2.h +++ b/ITS/AliITSclusterV2.h @@ -11,7 +11,7 @@ #include "TMath.h" #include "AliCluster.h" -#include "AliITSrecoV2.h" +#include "AliITSRecoParam.h" //_____________________________________________________________________________ class AliITSclusterV2 : public AliCluster { diff --git a/ITS/AliITSrecoV2.h b/ITS/AliITSrecoV2.h deleted file mode 100644 index 3ea6260dd16..00000000000 --- a/ITS/AliITSrecoV2.h +++ /dev/null @@ -1,57 +0,0 @@ -#ifndef ALIITSRECO_H -#define ALIITSRECO_H -/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * - * See cxx source for full Copyright notice */ - -//------------------------------------------------------------------------- -// ITS reconstruction name space -// -// Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch -//------------------------------------------------------------------------- -#include - -//namespace AliITSreco { - const Int_t kMaxClusterPerLayer=7000*10; - const Int_t kMaxClusterPerLayer5=7000*10*2/5; - const Int_t kMaxClusterPerLayer10=7000*10*2/10; - const Int_t kMaxClusterPerLayer20=7000*10*2/20; - const Int_t kMaxDetectorPerLayer=1000; - - const Int_t kLayersNotToSkip[6]={0,0,0,0,0,0}; - const Int_t kLastLayerToTrackTo=0; - - const Int_t kMaxLayer = 6; -const Double_t kMaxSnp = 3.; - const Double_t kSigmaY2[kMaxLayer]={ - 1.44e-6, 1.44e-6, 1.444e-5, 1.444e-5, 4.0e-6, 4.0e-6 - }; - const Double_t kSigmaZ2[kMaxLayer]={ - //4.9e-5, 4.9e-5, 7.84e-6, 7.84e-6, 0.006889, 0.006889 - 1.44e-4, 1.44e-4, 7.84e-6, 7.84e-6, 0.006889, 0.006889 - }; - - const Double_t kChi2PerCluster=9.; -// const Double_t kMaxChi2PerCluster[5]={7.,5.,8.,8.,6.5}; - const Double_t kMaxChi2PerCluster[5]={11,12,12,5,12}; - const Double_t kMaxNormChi2NonC[6] = {7,8,8,11,14,25}; //max norm chi2 for non constrained tracks - const Double_t kMaxNormChi2C[6] = {11,13,15,18,30,35}; //max norm chi2 for constrained tracks - - const Double_t kMaxChi2=35.; -// const Double_t kMaxChi2s[6]={40,40,40,40,40,40}; - const Double_t kMaxChi2s[6]={25,25,25,25,40,50}; - const Double_t kMaxChi2sR[6]={10,10,10,10,30,40}; - const Double_t kMaxChi2In=16.; - const Double_t kVertexCut=25; - const Double_t kMaxRoad=6.0; - - const Double_t kXV=0.0e+0; - const Double_t kYV=0.0e+0; - const Double_t kZV=0.0e+0; - const Double_t kSigmaXV=0.005e+0; - const Double_t kSigmaYV=0.005e+0; - const Double_t kSigmaZV=0.010e+0; -//} - -//using namespace AliITSreco; - -#endif diff --git a/ITS/AliITStrackMI.h b/ITS/AliITStrackMI.h index c413e0ed40e..4d28d5de6bb 100644 --- a/ITS/AliITStrackMI.h +++ b/ITS/AliITStrackMI.h @@ -27,7 +27,7 @@ #include -#include "AliITSrecoV2.h" +#include "AliITSRecoParam.h" #include "AliITStrackV2.h" class AliESDtrack; diff --git a/ITS/AliITStrackV2.h b/ITS/AliITStrackV2.h index bf7c174105f..e35881769d5 100644 --- a/ITS/AliITStrackV2.h +++ b/ITS/AliITStrackV2.h @@ -11,7 +11,7 @@ //------------------------------------------------------------------------- #include -#include "AliITSrecoV2.h" +#include "AliITSRecoParam.h" class AliESDtrack; diff --git a/ITS/AliITStrackerMI.cxx b/ITS/AliITStrackerMI.cxx index 2923c45c727..7b75bcf103b 100644 --- a/ITS/AliITStrackerMI.cxx +++ b/ITS/AliITStrackerMI.cxx @@ -35,6 +35,7 @@ #include "AliITSRecPoint.h" #include "AliITSgeomTGeo.h" #include "AliITStrackerMI.h" +#include "AliITSReconstructor.h" #include "AliTrackPointArray.h" #include "AliAlignObj.h" @@ -43,6 +44,7 @@ ClassImp(AliITStrackerMI) AliITStrackerMI::AliITSlayer AliITStrackerMI::fgLayers[kMaxLayer]; // ITS layers + AliITStrackerMI::AliITStrackerMI():AliTracker(), fI(0), fBestTrack(), @@ -59,8 +61,7 @@ fEsd(0), fDebugStreamer(0){ //Default constructor } - - +//------------------------------------------------------------------------ AliITStrackerMI::AliITStrackerMI(const Char_t *geom) : AliTracker(), fI(kMaxLayer), fBestTrack(), @@ -130,7 +131,12 @@ fDebugStreamer(0){ fPass=0; fConstraint[0]=1; fConstraint[1]=0; - Double_t xyz[]={kXV,kYV,kZV}, ers[]={kSigmaXV,kSigmaYV,kSigmaZV}; + Double_t xyz[]={AliITSReconstructor::GetRecoParam()->GetXVdef(), + AliITSReconstructor::GetRecoParam()->GetYVdef(), + AliITSReconstructor::GetRecoParam()->GetZVdef()}; + Double_t ers[]={AliITSReconstructor::GetRecoParam()->GetSigmaXVdef(), + AliITSReconstructor::GetRecoParam()->GetSigmaYVdef(), + AliITSReconstructor::GetRecoParam()->GetSigmaZVdef()}; SetVertex(xyz,ers); for (Int_t i=0; i~AliITStrackerMI(); new(this) AliITStrackerMI(tracker); return *this; } - - +//------------------------------------------------------------------------ AliITStrackerMI::~AliITStrackerMI() { // @@ -179,14 +184,14 @@ AliITStrackerMI::~AliITStrackerMI() delete fDebugStreamer; } } - +//------------------------------------------------------------------------ void AliITStrackerMI::SetLayersNotToSkip(Int_t *l) { //-------------------------------------------------------------------- //This function set masks of the layers which must be not skipped //-------------------------------------------------------------------- for (Int_t i=0; iGetV0Index(i); if (index==0) break; @@ -695,74 +699,96 @@ void AliITStrackerMI::FollowProlongationTree(AliITStrackMI * otrack, Int_t esdin } new(¤ttrack1) AliITStrackMI(tracks[ilayer+1][nindexes[ilayer+1][itrack]]); + + // material between SSD and SDD, SDD and SPD (to be done with TGeo) //AD if (ilayer==3 || ilayer==1) { - Double_t rs=0.5*(fgLayers[ilayer+1].GetR() + r); - Double_t d=0.0034, x0=38.6; - if (ilayer==1) {rs=9.; d=0.0097; x0=42;} - if (!currenttrack1.PropagateTo(rs,d,x0)) { - continue; + Double_t rshield,dshield,x0shield; + if(ilayer==3) { // SDDouter + rshield=0.5*(fgLayers[ilayer+1].GetR() + r); + dshield=0.0034; + x0shield=38.6; + } else { // SPDouter + rshield=9.; + dshield=0.0097; + x0shield=42.; } + if (!currenttrack1.PropagateTo(rshield,dshield,x0shield)) continue; } Double_t phi,z; if (!currenttrack1.GetPhiZat(r,phi,z)) continue; Int_t idet=layer.FindDetectorIndex(phi,z); - if (idet<0) { - continue; - } + if (idet<0) continue; + //propagate to the intersection const AliITSdetector &det=layer.GetDetector(idet); - phi=det.GetPhi(); new(¤ttrack2) AliITStrackMI(currenttrack1); - if (!currenttrack1.Propagate(phi,det.GetR())) { - continue; - } - currenttrack2.Propagate(phi,det.GetR()); // + if (!currenttrack1.Propagate(det.GetPhi(),det.GetR())) continue; + currenttrack2.Propagate(det.GetPhi(),det.GetR()); currenttrack1.SetDetectorIndex(idet); currenttrack2.SetDetectorIndex(idet); // + // definition of search road for clusters selection + Double_t dz=AliITSReconstructor::GetRecoParam()->GetNSigmaRoadZ()* + TMath::Sqrt(currenttrack1.GetSigmaZ2() + + AliITSReconstructor::GetRecoParam()->GetNSigmaZLayerForRoadZ()* + AliITSReconstructor::GetRecoParam()->GetNSigmaZLayerForRoadZ()* + AliITSReconstructor::GetRecoParam()->GetSigmaZ2(ilayer)); + Double_t dy=AliITSReconstructor::GetRecoParam()->GetNSigmaRoadY()* + TMath::Sqrt(currenttrack1.GetSigmaY2() + + AliITSReconstructor::GetRecoParam()->GetNSigmaYLayerForRoadY()* + AliITSReconstructor::GetRecoParam()->GetNSigmaYLayerForRoadY()* + AliITSReconstructor::GetRecoParam()->GetSigmaY2(ilayer)); // - Double_t dz=7.5*TMath::Sqrt(currenttrack1.GetSigmaZ2() + 16.*kSigmaZ2[ilayer]); - Double_t dy=7.5*TMath::Sqrt(currenttrack1.GetSigmaY2() + 16.*kSigmaY2[ilayer]); - // - Bool_t isBoundary=kFALSE; - if (currenttrack1.GetY()-dy< det.GetYmin()+0.2) isBoundary = kTRUE; - if (currenttrack1.GetY()+dy> det.GetYmax()-0.2) isBoundary = kTRUE; - if (currenttrack1.GetZ()-dz< det.GetZmin()+0.2) isBoundary = kTRUE; - if (currenttrack1.GetZ()+dz> det.GetZmax()-0.2) isBoundary = kTRUE; - - if (isBoundary){ // track at boundary between detectors - Float_t maxtgl = TMath::Abs(currenttrack1.GetTgl()); - if (maxtgl>1) maxtgl=1; - dz = TMath::Sqrt(dz*dz+0.25*maxtgl*maxtgl); + // track at boundary between detectors, enlarge road + if ( (currenttrack1.GetY()-dy < det.GetYmin()+0.2) || + (currenttrack1.GetY()+dy > det.GetYmax()-0.2) || + (currenttrack1.GetZ()-dz < det.GetZmin()+0.2) || + (currenttrack1.GetZ()+dz > det.GetZmax()-0.2) ) { + Float_t maxtgl = TMath::Abs(currenttrack1.GetTgl()); + if (maxtgl > 1.) maxtgl=1.; + dz = TMath::Sqrt(dz*dz+0.5*0.5*maxtgl*maxtgl); //AD // Float_t maxsnp = TMath::Abs(currenttrack1.GetSnp()); - if (maxsnp>0.95) continue; + if (maxsnp > AliITSReconstructor::GetRecoParam()->GetMaxSnp()) continue; //if (maxsnp>0.5) maxsnp=0.5; - dy=TMath::Sqrt(dy*dy+0.25*maxsnp*maxsnp); - } + dy = TMath::Sqrt(dy*dy+0.5*0.5*maxsnp*maxsnp); //AD + } // boundary - Double_t zmin=currenttrack1.GetZ() - dz; - Double_t zmax=currenttrack1.GetZ() + dz; - Double_t ymin=currenttrack1.GetY() + r*phi - dy; - Double_t ymax=currenttrack1.GetY() + r*phi + dy; + // road in global (rphi,z) + Double_t zmin = currenttrack1.GetZ() - dz; + Double_t zmax = currenttrack1.GetZ() + dz; + Double_t ymin = currenttrack1.GetY() + r*det.GetPhi() - dy; + Double_t ymax = currenttrack1.GetY() + r*det.GetPhi() + dy; + // select clusters layer.SelectClusters(zmin,zmax,ymin,ymax); + + // road for track-cluster association + Double_t msz = currenttrack1.GetSigmaZ2() + + AliITSReconstructor::GetRecoParam()->GetNSigmaZLayerForRoadZ()* + AliITSReconstructor::GetRecoParam()->GetNSigmaZLayerForRoadZ()* + AliITSReconstructor::GetRecoParam()->GetSigmaZ2(ilayer); + Double_t msy = currenttrack1.GetSigmaY2() + + AliITSReconstructor::GetRecoParam()->GetNSigmaYLayerForRoadY()* + AliITSReconstructor::GetRecoParam()->GetNSigmaYLayerForRoadY()* + AliITSReconstructor::GetRecoParam()->GetSigmaY2(ilayer); + if (constrain) { + msz *= AliITSReconstructor::GetRecoParam()->GetNSigma2RoadZC(); + msy *= AliITSReconstructor::GetRecoParam()->GetNSigma2RoadYC(); + } else { + msz *= AliITSReconstructor::GetRecoParam()->GetNSigma2RoadZNonC(); + msy *= AliITSReconstructor::GetRecoParam()->GetNSigma2RoadYNonC(); + } + msz = 1./msz; // 1/RoadZ^2 + msy = 1./msy; // 1/RoadY^2 // - // loop over all possible prolongations // - Double_t msz=1./((currenttrack1.GetSigmaZ2() + 16.*kSigmaZ2[ilayer])); - Double_t msy=1./((currenttrack1.GetSigmaY2() + 16.*kSigmaY2[ilayer])); - if (constrain){ - msy/=60; msz/=60.; - } - else{ - msy/=50; msz/=50.; - } + // loop over all possible prolongations // const AliITSRecPoint *c=0; Int_t ci=-1; - Double_t chi2=12345.; + Double_t chi2=AliITSReconstructor::GetRecoParam()->GetMaxChi2(); Int_t deadzone=0; currenttrack = ¤ttrack1; while ((c=layer.GetNextCluster(ci))!=0) { @@ -770,12 +796,13 @@ void AliITStrackerMI::FollowProlongationTree(AliITStrackMI * otrack, Int_t esdin Bool_t change =kFALSE; if (c->GetQ()==0 && (deadzone==1)) continue; Int_t idet=c->GetDetectorIndex(); - if (currenttrack->GetDetectorIndex()!=idet) { + if (currenttrack->GetDetectorIndex()!=idet) { // move track to cluster's detector const AliITSdetector &det=layer.GetDetector(idet); Double_t y,z; if (!currenttrack2.GetProlongationFast(det.GetPhi(),det.GetR(),y,z)) continue; - Float_t pz = (z - c->GetZ()) , py=(y - c->GetY()); - if (pz*pz*msz+py*py*msy>1.) continue; + if ( (z-c->GetZ())*(z-c->GetZ())*msz + + (y-c->GetY())*(y-c->GetY())*msy > 1. ) + continue; // cluster not associated to track // new (&backuptrack) AliITStrackMI(currenttrack2); change = kTRUE; @@ -786,14 +813,14 @@ void AliITStrackerMI::FollowProlongationTree(AliITStrackMI * otrack, Int_t esdin continue; } currenttrack->SetDetectorIndex(idet); - } - else{ - Float_t pz = (currenttrack->GetZ() - c->GetZ()) , py=(currenttrack->GetY() - c->GetY()); - if (pz*pz*msz+py*py*msy>1.) continue; + } else { // track already on the cluster's detector + if ( (currenttrack->GetZ()-c->GetZ())*(currenttrack->GetZ()-c->GetZ())*msz + + (currenttrack->GetY()-c->GetY())*(currenttrack->GetY()-c->GetY())*msy > 1. ) + continue; // cluster not associated to track } - chi2=GetPredictedChi2MI(currenttrack,c,ilayer); - if (chi2GetMaxChi2s(ilayer)) { if (c->GetQ()==0) deadzone=1; // take dead zone only once if (ntracks[ilayer]>=100) continue; AliITStrackMI * updatetrack = new (&tracks[ilayer][ntracks[ilayer]]) AliITStrackMI(*currenttrack); @@ -804,14 +831,11 @@ void AliITStrackerMI::FollowProlongationTree(AliITStrackMI * otrack, Int_t esdin if (c->GetQ()!=0){ if (!UpdateMI(updatetrack,c,chi2,(ilayer<<28)+ci)) continue; updatetrack->SetSampledEdx(c->GetQ(),updatetrack->GetNumberOfClusters()-1); //b.b. - } - else { + } else { updatetrack->SetNDeadZone(updatetrack->GetNDeadZone()+1); updatetrack->SetDeadZoneProbability(GetDeadZoneProbability(updatetrack->GetZ(),TMath::Sqrt(updatetrack->GetSigmaZ2()))); } - if (c->IsUsed()){ - updatetrack->IncrementNUsed(); - } + if (c->IsUsed()) updatetrack->IncrementNUsed(); Double_t x0; Double_t d=layer.GetThickness(updatetrack->GetY(),updatetrack->GetZ(),x0); updatetrack->CorrectForMaterial(d,x0); @@ -820,16 +844,16 @@ void AliITStrackerMI::FollowProlongationTree(AliITStrackMI * otrack, Int_t esdin fI = ilayer; Double_t d=GetEffectiveThickness(0,0); //Think of this !!!! Double_t xyz[]={GetX(),GetY(),GetZ()}; - Double_t ptfactor = 1; + Double_t ptfactor = 1;//AD Double_t ers[]={GetSigmaX()*ptfactor,GetSigmaY()*ptfactor,GetSigmaZ()}; Bool_t isPrim = kTRUE; if (ilayer<4){ //updatetrack->fD[0] = updatetrack->GetD(GetX(),GetY()); //updatetrack->fD[1] = updatetrack->GetZat(GetX())-GetZ(); updatetrack->GetDZ(GetX(),GetY(),GetZ(),updatetrack->GetDP()); //I.B. - if ( TMath::Abs(updatetrack->GetD(0)/(1.+ilayer))>0.4 || TMath::Abs(updatetrack->GetD(1)/(1.+ilayer))>0.4) isPrim=kFALSE; + if ( TMath::Abs(updatetrack->GetD(0)/(1.+ilayer))>0.4 || TMath::Abs(updatetrack->GetD(1)/(1.+ilayer))>0.4) isPrim=kFALSE; //AD } - if (isPrim) updatetrack->Improve(d,xyz,ers); + if (isPrim) updatetrack->Improve(d,xyz,ers); //AD } //apply vertex constrain ntracks[ilayer]++; } // create new hypothesy @@ -868,52 +892,56 @@ void AliITStrackerMI::FollowProlongationTree(AliITStrackMI * otrack, Int_t esdin Int_t golds=0; for (Int_t itrack=0;itrack4) accepted++; - else{ - if ( constrain && normalizedchi2[itrack]4) { + accepted++; + } else { + if (constrain) { // constrain + if (normalizedchi2[itrack]GetMaxNormChi2C(ilayer)+1) accepted++; + } else { // !constrain + if (normalizedchi2[itrack]GetMaxNormChi2NonC(ilayer)+1) accepted++; + } } } TMath::Sort(ntracks[ilayer],normalizedchi2,nindexes[ilayer],kFALSE); ntracks[ilayer] = TMath::Min(accepted,7+2*ilayer); if (ntracks[ilayer]90) ntracks[ilayer]=90; - } //loop over layers + } // endloop over layers //printf("%d\t%d\t%d\t%d\t%d\t%d\n",ntracks[0],ntracks[1],ntracks[2],ntracks[3],ntracks[4],ntracks[5]); - Int_t max = constrain? 20: 5; + Int_t max = constrain ? 20 : 5; - for (Int_t i=0;i7.)continue; + if (!constrain&&track.GetNormChi2(0)>7.)continue; //AD AddTrackHypothesys(new AliITStrackMI(track), esdindex); } for (Int_t i=0;i7.)continue; + if (!constrain&&track.GetNormChi2(1)>7.)continue; //AD if (constrain) track.IncrementNSkipped(); if (!constrain) { track.SetD(0,track.GetD(GetX(),GetY())); - track.SetNSkipped(track.GetNSkipped()+4./(4.+8.*TMath::Abs(track.GetD(0)))); + track.SetNSkipped(track.GetNSkipped()+4./(4.+8.*TMath::Abs(track.GetD(0)))); //AD if (track.GetNumberOfClusters()+track.GetNDeadZone()+track.GetNSkipped()>6) { track.SetNSkipped(6-track.GetNumberOfClusters()+track.GetNDeadZone()); } } AddTrackHypothesys(new AliITStrackMI(track), esdindex); } - //} + if (!constrain){ for (Int_t i=0;i7.)continue; + if (!constrain&&track.GetNormChi2(2)>7.)continue; //AD if (constrain) track.SetNSkipped(track.GetNSkipped()+2); if (!constrain){ track.SetD(0,track.GetD(GetX(),GetY())); - track.SetNSkipped(track.GetNSkipped()+7./(7.+8.*TMath::Abs(track.GetD(0)))); + track.SetNSkipped(track.GetNSkipped()+7./(7.+8.*TMath::Abs(track.GetD(0)))); //AD if (track.GetNumberOfClusters()+track.GetNDeadZone()+track.GetNSkipped()>6) { track.SetNSkipped(6-track.GetNumberOfClusters()+track.GetNDeadZone()); } @@ -942,7 +970,7 @@ void AliITStrackerMI::FollowProlongationTree(AliITStrackMI * otrack, Int_t esdin for (Int_t i=0;i<3;i++){ Int_t index = otrack->GetESDtrack()->GetV0Index(i); if (index==0) break; - AliV0 * vertex = (AliV0*)fEsd->GetV0(index); + AliV0 *vertex = (AliV0*)fEsd->GetV0(index); if (vertex->GetStatus()<0) continue; // rejected V0 // if (otrack->GetSign()>0) { @@ -968,7 +996,7 @@ void AliITStrackerMI::FollowProlongationTree(AliITStrackMI * otrack, Int_t esdin if (track.GetSign()>0) { vertex->SetParamP(track); vertex->Update(fprimvertex); - // vertex->SetIndex(0,track.fESDtrack->GetID()); + //vertex->SetIndex(0,track.fESDtrack->GetID()); if (track.GetNumberOfClusters()>2) AddTrackHypothesys(new AliITStrackMI(track), esdindex); }else{ vertex->SetParamN(track); @@ -978,23 +1006,22 @@ void AliITStrackerMI::FollowProlongationTree(AliITStrackMI * otrack, Int_t esdin } vertex->SetStatus(vertex->GetStatus()+1); }else{ - // vertex->SetStatus(-2); // reject V0 - not enough clusters + //vertex->SetStatus(-2); // reject V0 - not enough clusters } } - // if (nearestold>3){ -// Int_t indexlayer = (ntracks[0]>0)? 0:1; -// if (ntracks[indexlayer]>0){ -// AliITStrackMI & track= tracks[indexlayer][nindexes[indexlayer][0]]; -// if (track.GetNumberOfClusters()>4&&track.fNormChi2[indexlayer]<4){ -// vertex->SetStatus(-1); // reject V0 - clusters before -// } -// } -// } + //if (nearestold>3){ + // Int_t indexlayer = (ntracks[0]>0)? 0:1; + // if (ntracks[indexlayer]>0){ + // AliITStrackMI & track= tracks[indexlayer][nindexes[indexlayer][0]]; + // if (track.GetNumberOfClusters()>4&&track.fNormChi2[indexlayer]<4){ + // vertex->SetStatus(-1); // reject V0 - clusters before + // } + // } + //} } } } - - +//------------------------------------------------------------------------ AliITStrackerMI::AliITSlayer & AliITStrackerMI::GetLayer(Int_t layer) const { //-------------------------------------------------------------------- @@ -1002,7 +1029,7 @@ AliITStrackerMI::AliITSlayer & AliITStrackerMI::GetLayer(Int_t layer) const // return fgLayers[layer]; } - +//------------------------------------------------------------------------ AliITStrackerMI::AliITSlayer::AliITSlayer(): fR(0), fPhiOffset(0), @@ -1039,7 +1066,7 @@ fRoad(0){ fClusterTracks[3][i]=-1; } } - +//------------------------------------------------------------------------ AliITStrackerMI::AliITSlayer:: AliITSlayer(Double_t r,Double_t p,Double_t z,Int_t nl,Int_t nd): fR(r), @@ -1072,7 +1099,7 @@ fRoad(0) { fDetectors=new AliITSdetector[fNladders*fNdetectors]; fRoad=2*fR*TMath::Sqrt(3.14/1.);//assuming that there's only one cluster } - +//------------------------------------------------------------------------ AliITStrackerMI::AliITSlayer::AliITSlayer(const AliITSlayer& layer): fR(layer.fR), fPhiOffset(layer.fPhiOffset), @@ -1100,8 +1127,7 @@ fAccepted(layer.fAccepted), fRoad(layer.fRoad){ //Copy constructor } - - +//------------------------------------------------------------------------ AliITStrackerMI::AliITSlayer::~AliITSlayer() { //-------------------------------------------------------------------- // AliITSlayer destructor @@ -1116,7 +1142,7 @@ AliITStrackerMI::AliITSlayer::~AliITSlayer() { fClusterTracks[3][i]=-1; } } - +//------------------------------------------------------------------------ void AliITStrackerMI::AliITSlayer::ResetClusters() { //-------------------------------------------------------------------- // This function removes loaded clusters @@ -1133,7 +1159,7 @@ void AliITStrackerMI::AliITSlayer::ResetClusters() { fN=0; fI=0; } - +//------------------------------------------------------------------------ void AliITStrackerMI::AliITSlayer::ResetWeights() { //-------------------------------------------------------------------- // This function reset weights of the clusters @@ -1151,7 +1177,7 @@ void AliITStrackerMI::AliITSlayer::ResetWeights() { } } - +//------------------------------------------------------------------------ void AliITStrackerMI::AliITSlayer::ResetRoad() { //-------------------------------------------------------------------- // This function calculates the road defined by the cluster density @@ -1163,8 +1189,7 @@ void AliITStrackerMI::AliITSlayer::ResetRoad() { //if (n>1) fRoad=2*fR*TMath::Sqrt(3.14/n); if (n>1) fRoad=2*fR*TMath::Sqrt(3.14/n); } - - +//------------------------------------------------------------------------ Int_t AliITStrackerMI::AliITSlayer::InsertCluster(AliITSRecPoint *c) { //-------------------------------------------------------------------- //This function adds a cluster to this layer @@ -1184,7 +1209,7 @@ Int_t AliITStrackerMI::AliITSlayer::InsertCluster(AliITSRecPoint *c) { return 0; } - +//------------------------------------------------------------------------ void AliITStrackerMI::AliITSlayer::SortClusters() { // @@ -1289,8 +1314,7 @@ void AliITStrackerMI::AliITSlayer::SortClusters() } - - +//------------------------------------------------------------------------ Int_t AliITStrackerMI::AliITSlayer::FindClusterIndex(Float_t z) const { //-------------------------------------------------------------------- // This function returns the index of the nearest cluster @@ -1315,8 +1339,7 @@ Int_t AliITStrackerMI::AliITSlayer::FindClusterIndex(Float_t z) const { } return m; } - - +//------------------------------------------------------------------------ void AliITStrackerMI::AliITSlayer:: SelectClusters(Double_t zmin,Double_t zmax,Double_t ymin, Double_t ymax) { //-------------------------------------------------------------------- @@ -1392,10 +1415,7 @@ SelectClusters(Double_t zmin,Double_t zmax,Double_t ymin, Double_t ymax) { fSkip = 0; fAccepted =0; } - - - - +//------------------------------------------------------------------------ Int_t AliITStrackerMI::AliITSlayer:: FindDetectorIndex(Double_t phi, Double_t z) const { //-------------------------------------------------------------------- @@ -1420,8 +1440,7 @@ FindDetectorIndex(Double_t phi, Double_t z) const { return np*fNdetectors + nz; } - - +//------------------------------------------------------------------------ const AliITSRecPoint *AliITStrackerMI::AliITSlayer::GetNextCluster(Int_t &ci){ //-------------------------------------------------------------------- // This function returns clusters within the "window" @@ -1453,9 +1472,7 @@ const AliITSRecPoint *AliITStrackerMI::AliITSlayer::GetNextCluster(Int_t &ci){ } return 0; } - - - +//------------------------------------------------------------------------ Double_t AliITStrackerMI::AliITSlayer::GetThickness(Double_t y,Double_t z,Double_t &x0) const { //-------------------------------------------------------------------- @@ -1555,7 +1572,7 @@ const { return d; } - +//------------------------------------------------------------------------ Double_t AliITStrackerMI::GetEffectiveThickness(Double_t y,Double_t z) const { //-------------------------------------------------------------------- @@ -1582,7 +1599,7 @@ Double_t AliITStrackerMI::GetEffectiveThickness(Double_t y,Double_t z) const return d/(xn*xn); } - +//------------------------------------------------------------------------ Int_t AliITStrackerMI::AliITSlayer::InRoad() const { //-------------------------------------------------------------------- // This function returns number of clusters within the "window" @@ -1604,7 +1621,7 @@ Int_t AliITStrackerMI::AliITSlayer::InRoad() const { } return ncl; } - +//------------------------------------------------------------------------ Bool_t AliITStrackerMI::RefitAt(Double_t xx,AliITStrackMI *t, const AliITStrackMI *c, Bool_t extra) { //-------------------------------------------------------------------- @@ -1670,7 +1687,7 @@ Bool_t AliITStrackerMI::RefitAt(Double_t xx,AliITStrackMI *t, t->SetDetectorIndex(idet); const AliITSRecPoint *cl=0; - Double_t maxchi2=1000.*kMaxChi2; + Double_t maxchi2=1000.*AliITSReconstructor::GetRecoParam()->GetMaxChi2(); Int_t idx=index[i]; if (idx>=0) { @@ -1712,9 +1729,9 @@ Bool_t AliITStrackerMI::RefitAt(Double_t xx,AliITStrackMI *t, if (extra) { //search for extra clusters AliITStrackV2 tmp(*t); - Double_t dz=4*TMath::Sqrt(tmp.GetSigmaZ2()+kSigmaZ2[i]); + Double_t dz=4*TMath::Sqrt(tmp.GetSigmaZ2()+AliITSReconstructor::GetRecoParam()->GetSigmaZ2(i)); if (dz < 0.5*TMath::Abs(tmp.GetTgl())) dz=0.5*TMath::Abs(tmp.GetTgl()); - Double_t dy=4*TMath::Sqrt(t->GetSigmaY2()+kSigmaY2[i]); + Double_t dy=4*TMath::Sqrt(t->GetSigmaY2()+AliITSReconstructor::GetRecoParam()->GetSigmaY2(i)); if (dy < 0.5*TMath::Abs(tmp.GetSnp())) dy=0.5*TMath::Abs(tmp.GetSnp()); Double_t zmin=t->GetZ() - dz; Double_t zmax=t->GetZ() + dz; @@ -1723,7 +1740,7 @@ Bool_t AliITStrackerMI::RefitAt(Double_t xx,AliITStrackMI *t, layer.SelectClusters(zmin,zmax,ymin,ymax); const AliITSRecPoint *c=0; Int_t ci=-1,cci=-1; - Double_t maxchi2=1000.*kMaxChi2, tolerance=0.1; + Double_t maxchi2=1000.*AliITSReconstructor::GetRecoParam()->GetMaxChi2(), tolerance=0.1; while ((c=layer.GetNextCluster(ci))!=0) { if (idet == c->GetDetectorIndex()) continue; @@ -1755,7 +1772,7 @@ Bool_t AliITStrackerMI::RefitAt(Double_t xx,AliITStrackMI *t, if (!t->PropagateTo(xx,0.,0.)) return kFALSE; return kTRUE; } - +//------------------------------------------------------------------------ Bool_t AliITStrackerMI::RefitAt(Double_t xx,AliITStrackMI *t,const Int_t *clindex) { //-------------------------------------------------------------------- @@ -1816,7 +1833,7 @@ AliITStrackerMI::RefitAt(Double_t xx,AliITStrackMI *t,const Int_t *clindex) { t->SetDetectorIndex(idet); const AliITSRecPoint *cl=0; - Double_t maxchi2=1000.*kMaxChi2; + Double_t maxchi2=1000.*AliITSReconstructor::GetRecoParam()->GetMaxChi2(); Int_t idx=index[i]; if (idx>=0) { @@ -1844,8 +1861,8 @@ AliITStrackerMI::RefitAt(Double_t xx,AliITStrackMI *t,const Int_t *clindex) { /* if (cl==0) if (t->GetNumberOfClusters()>2) { - Double_t dz=4*TMath::Sqrt(t->GetSigmaZ2()+kSigmaZ2[i]); - Double_t dy=4*TMath::Sqrt(t->GetSigmaY2()+kSigmaY2[i]); + Double_t dz=4*TMath::Sqrt(t->GetSigmaZ2()+AliITSReconstructor::GetRecoParam()->GetSigmaZ2(i)); + Double_t dy=4*TMath::Sqrt(t->GetSigmaY2()+AliITSReconstructor::GetRecoParam()->GetSigmaY2(i)); Double_t zmin=t->GetZ() - dz; Double_t zmax=t->GetZ() + dz; Double_t ymin=t->GetY() + phi*r - dy; @@ -1889,7 +1906,7 @@ AliITStrackerMI::RefitAt(Double_t xx,AliITStrackMI *t,const Int_t *clindex) { if (!t->PropagateTo(xx,0.,0.)) return kFALSE; return kTRUE; } - +//------------------------------------------------------------------------ Double_t AliITStrackerMI::GetNormalizedChi2(AliITStrackMI * track, Int_t mode) { // @@ -1985,8 +2002,7 @@ Double_t AliITStrackerMI::GetNormalizedChi2(AliITStrackMI * track, Int_t mode) return normchi2; } - - +//------------------------------------------------------------------------ Double_t AliITStrackerMI::GetMatchingChi2(AliITStrackMI * track1, AliITStrackMI * track2) { // @@ -2026,7 +2042,7 @@ Double_t AliITStrackerMI::GetMatchingChi2(AliITStrackMI * track1, AliITStrackMI TMatrixD chi2(vec2,TMatrixD::kTransposeMult,vec); return chi2(0,0); } - +//------------------------------------------------------------------------ Double_t AliITStrackerMI::GetDeadZoneProbability(Double_t zpos, Double_t zerr) { // @@ -2049,8 +2065,7 @@ Double_t AliITStrackerMI::GetDeadZoneProbability(Double_t zpos, Double_t zerr) probability = (TMath::Erf((zpos-zmin)/zerr) - TMath::Erf((zpos-zmax)/zerr))*0.5; return probability; } - - +//------------------------------------------------------------------------ Double_t AliITStrackerMI::GetTruncatedChi2(AliITStrackMI * track, Float_t fac) { // @@ -2078,8 +2093,7 @@ Double_t AliITStrackerMI::GetTruncatedChi2(AliITStrackMI * track, Float_t fac) Double_t normchi2 = sumchi/sumweight; return normchi2; } - - +//------------------------------------------------------------------------ Double_t AliITStrackerMI::GetInterpolatedChi2(AliITStrackMI * forwardtrack, AliITStrackMI * backtrack) { // @@ -2111,11 +2125,7 @@ Double_t AliITStrackerMI::GetInterpolatedChi2(AliITStrackMI * forwardtrack, AliI 1./(1.+forwardtrack->GetNSkipped())); return 1000; } - - - - - +//------------------------------------------------------------------------ Float_t *AliITStrackerMI::GetWeight(Int_t index) { //-------------------------------------------------------------------- // Return pointer to a given cluster @@ -2124,7 +2134,7 @@ Float_t *AliITStrackerMI::GetWeight(Int_t index) { Int_t c=(index & 0x0fffffff) >> 00; return fgLayers[l].GetWeight(c); } - +//------------------------------------------------------------------------ void AliITStrackerMI::RegisterClusterTracks(AliITStrackMI* track,Int_t id) { //--------------------------------------------- @@ -2146,6 +2156,7 @@ void AliITStrackerMI::RegisterClusterTracks(AliITStrackMI* track,Int_t id) } } } +//------------------------------------------------------------------------ void AliITStrackerMI::UnRegisterClusterTracks(AliITStrackMI* track, Int_t id) { //--------------------------------------------- @@ -2162,6 +2173,7 @@ void AliITStrackerMI::UnRegisterClusterTracks(AliITStrackMI* track, Int_t id) } } } +//------------------------------------------------------------------------ Float_t AliITStrackerMI::GetNumberOfSharedClusters(AliITStrackMI* track,Int_t id, Int_t list[6], AliITSRecPoint *clist[6]) { //------------------------------------------------------------- @@ -2208,7 +2220,7 @@ Float_t AliITStrackerMI::GetNumberOfSharedClusters(AliITStrackMI* track,Int_t id track->SetNUsed(shared); return shared; } - +//------------------------------------------------------------------------ Int_t AliITStrackerMI::GetOverlapTrack(AliITStrackMI *track, Int_t trackID, Int_t &shared, Int_t clusterlist[6],Int_t overlist[6]) { // @@ -2317,8 +2329,7 @@ Int_t AliITStrackerMI::GetOverlapTrack(AliITStrackMI *track, Int_t trackID, Int_ } return sharedtrack; } - - +//------------------------------------------------------------------------ AliITStrackMI * AliITStrackerMI::GetBest2Tracks(Int_t trackID1, Int_t trackID2, Float_t th0, Float_t th1){ // // try to find track hypothesys without conflicts @@ -2551,22 +2562,22 @@ AliITStrackMI * AliITStrackerMI::GetBest2Tracks(Int_t trackID1, Int_t trackID2, UnRegisterClusterTracks(track,trackID2); } - if (track10->GetConstrain()&&track10->GetChi2MIP(0)GetChi2MIP(1)GetChi2MIP(2)GetChi2MIP(3)fChi2MIP[0]fChi2MIP[1]fChi2MIP[2]fChi2MIP[3]GetConstrain()&&track10->GetChi2MIP(0)GetMaxChi2PerCluster(0)&&track10->GetChi2MIP(1)GetMaxChi2PerCluster(1) + &&track10->GetChi2MIP(2)GetMaxChi2PerCluster(2)&&track10->GetChi2MIP(3)GetMaxChi2PerCluster(3)){ + // if (track10->fChi2MIP[0]GetMaxChi2PerCluster(0)&&track10->fChi2MIP[1]GetMaxChi2PerCluster(1) + // &&track10->fChi2MIP[2]GetMaxChi2PerCluster(2)&&track10->fChi2MIP[3]GetMaxChi2PerCluster(3)){ RegisterClusterTracks(track10,trackID1); } - if (track20->GetConstrain()&&track20->GetChi2MIP(0)GetChi2MIP(1)GetChi2MIP(2)GetChi2MIP(3)fChi2MIP[0]fChi2MIP[1]fChi2MIP[2]fChi2MIP[3]GetConstrain()&&track20->GetChi2MIP(0)GetMaxChi2PerCluster(0)&&track20->GetChi2MIP(1)GetMaxChi2PerCluster(1) + &&track20->GetChi2MIP(2)GetMaxChi2PerCluster(2)&&track20->GetChi2MIP(3)GetMaxChi2PerCluster(3)){ + //if (track20->fChi2MIP[0]GetMaxChi2PerCluster(0)&&track20->fChi2MIP[1]GetMaxChi2PerCluster(1) + // &&track20->fChi2MIP[2]GetMaxChi2PerCluster(2)&&track20->fChi2MIP[3]GetMaxChi2PerCluster(3)){ RegisterClusterTracks(track20,trackID2); } return track10; } - +//------------------------------------------------------------------------ void AliITStrackerMI::UseClusters(const AliKalmanTrack *t, Int_t from) const { //-------------------------------------------------------------------- // This function marks clusters assigned to the track @@ -2581,8 +2592,7 @@ void AliITStrackerMI::UseClusters(const AliKalmanTrack *t, Int_t from) const { if (c->GetSigmaZ2()>0.1) c->Use(); } - - +//------------------------------------------------------------------------ void AliITStrackerMI::AddTrackHypothesys(AliITStrackMI * track, Int_t esdindex) { //------------------------------------------------------------------ @@ -2598,7 +2608,7 @@ void AliITStrackerMI::AddTrackHypothesys(AliITStrackMI * track, Int_t esdindex) } array->AddLast(track); } - +//------------------------------------------------------------------------ void AliITStrackerMI::SortTrackHypothesys(Int_t esdindex, Int_t maxcut, Int_t mode) { //------------------------------------------------------------------- @@ -2625,8 +2635,8 @@ void AliITStrackerMI::SortTrackHypothesys(Int_t esdindex, Int_t maxcut, Int_t mo track->SetFakeRatio(1.); CookLabel(track,0.); //For comparison only // - //if (chi2fFakeRatio==0){ - if (chi2GetMaxChi2PerCluster(0)&&track->fFakeRatio==0){ + if (chi2GetMaxChi2PerCluster(0)){ if (track->GetNumberOfClusters()GetNumberOfClusters(); if (chi2At(itrack); if (track){ track->SetChi2MIP(0,GetNormalizedChi2(track, mode)); - if (track->GetChi2MIP(0)GetChi2MIP(0)GetMaxChi2PerCluster(0)) chi2[itrack] = track->GetChi2MIP(0); else{ if (track->GetConstrain() || track->GetNumberOfClusters()>5){ //keep best short tracks - without vertex constrain @@ -2676,7 +2686,7 @@ void AliITStrackerMI::SortTrackHypothesys(Int_t esdindex, Int_t maxcut, Int_t mo // TMath::Sort(entries,chi2,index,kFALSE); besttrack = (AliITStrackMI*)array->At(index[0]); - if (besttrack&&besttrack->GetChi2MIP(0)GetChi2MIP(0)GetMaxChi2PerCluster(0)){ for (Int_t i=0;i<6;i++){ if (besttrack->GetClIndex(i)>0){ erry[i] = besttrack->GetSigmaY(i); erry[i+6] = besttrack->GetSigmaY(i+6); @@ -2693,7 +2703,7 @@ void AliITStrackerMI::SortTrackHypothesys(Int_t esdindex, Int_t maxcut, Int_t mo AliITStrackMI * track = (AliITStrackMI*)array->At(itrack); if (track){ track->SetChi2MIP(0,GetNormalizedChi2(track,mode)); - if (track->GetChi2MIP(0)GetChi2MIP(0)GetMaxChi2PerCluster(0)) chi2[itrack] = track->GetChi2MIP(0)-0*(track->GetNumberOfClusters()+track->GetNDeadZone()); else { @@ -2721,7 +2731,7 @@ void AliITStrackerMI::SortTrackHypothesys(Int_t esdindex, Int_t maxcut, Int_t mo } } besttrack->SetChi2MIP(0,GetNormalizedChi2(besttrack,mode)); - Float_t minchi2 = TMath::Min(besttrack->GetChi2MIP(0)+5.+besttrack->GetNUsed(), double(kMaxChi2PerCluster[0])); + Float_t minchi2 = TMath::Min(besttrack->GetChi2MIP(0)+5.+besttrack->GetNUsed(), double(AliITSReconstructor::GetRecoParam()->GetMaxChi2PerCluster(0))); Float_t minn = besttrack->GetNumberOfClusters()-3; Int_t accepted=0; for (Int_t i=0;iSetChi2MIP(1,NormalizedChi2(backtrack,0)); //for (Int_t i=2;i<6;i++){track->fDy[i]+=backtrack->fDy[i]; track->fDz[i]+=backtrack->fDz[i];} - if (track->GetChi2MIP(1)>kMaxChi2PerCluster[1]*6.) continue; + if (track->GetChi2MIP(1)>AliITSReconstructor::GetRecoParam()->GetMaxChi2PerCluster(1)*6.) continue; track->SetChi22(GetMatchingChi2(backtrack,original)); if ((track->GetConstrain()) && track->GetChi22()>90.) continue; @@ -2829,7 +2837,7 @@ AliITStrackMI * AliITStrackerMI::GetBestHypothesys(Int_t esdindex, AliITStrackMI if ( track->GetChi22()/track->GetNumberOfClusters()>11.) continue; - if (!(track->GetConstrain())&&track->GetChi2MIP(1)>kMaxChi2PerCluster[1]) continue; + if (!(track->GetConstrain())&&track->GetChi2MIP(1)>AliITSReconstructor::GetRecoParam()->GetMaxChi2PerCluster(1)) continue; Bool_t isOK=kTRUE; if(!isOK) continue; // @@ -2839,8 +2847,8 @@ AliITStrackMI * AliITStrackerMI::GetBestHypothesys(Int_t esdindex, AliITStrackMI x = track->GetX(); RefitAt(x,forwardtrack,track); track->SetChi2MIP(2,NormalizedChi2(forwardtrack,0)); - if (track->GetChi2MIP(2)>kMaxChi2PerCluster[2]*6.0) continue; - if (!(track->GetConstrain())&&track->GetChi2MIP(2)>kMaxChi2PerCluster[2]) continue; + if (track->GetChi2MIP(2)>AliITSReconstructor::GetRecoParam()->GetMaxChi2PerCluster(2)*6.0) continue; + if (!(track->GetConstrain())&&track->GetChi2MIP(2)>AliITSReconstructor::GetRecoParam()->GetMaxChi2PerCluster(2)) continue; //track->fD[0] = forwardtrack->GetD(GetX(),GetY()); //track->fD[1] = forwardtrack->GetZat(GetX())-GetZ(); @@ -2855,8 +2863,8 @@ AliITStrackMI * AliITStrackerMI::GetBestHypothesys(Int_t esdindex, AliITStrackMI } track->SetChi2MIP(3,GetInterpolatedChi2(forwardtrack,backtrack)); - if ( (track->GetChi2MIP(3)>6.*kMaxChi2PerCluster[3])) continue; - if ( (!track->GetConstrain()) && (track->GetChi2MIP(3)>2*kMaxChi2PerCluster[3])) { + if ( (track->GetChi2MIP(3)>6.*AliITSReconstructor::GetRecoParam()->GetMaxChi2PerCluster(3))) continue; + if ( (!track->GetConstrain()) && (track->GetChi2MIP(3)>2*AliITSReconstructor::GetRecoParam()->GetMaxChi2PerCluster(3))) { track->SetChi2MIP(3,1000); continue; } @@ -2883,7 +2891,7 @@ AliITStrackMI * AliITStrackerMI::GetBestHypothesys(Int_t esdindex, AliITStrackMI AliITStrackMI * track = (AliITStrackMI*)array->At(i); if (!track) continue; - if (accepted>checkmax || track->GetChi2MIP(3)>kMaxChi2PerCluster[3]*6. || + if (accepted>checkmax || track->GetChi2MIP(3)>AliITSReconstructor::GetRecoParam()->GetMaxChi2PerCluster(3)*6. || (track->GetNumberOfClusters()GetNumberOfClusters()-1.)|| track->GetChi2MIP(0)>besttrack->GetChi2MIP(0)+2.*besttrack->GetNUsed()+3.){ if (track->GetConstrain() || track->GetNumberOfClusters()>5){ //keep best short tracks - without vertex constrain @@ -2922,8 +2930,8 @@ AliITStrackMI * AliITStrackerMI::GetBestHypothesys(Int_t esdindex, AliITStrackMI Int_t list[6]; AliITSRecPoint * clist[6]; Float_t shared = GetNumberOfSharedClusters(besttrack,esdindex,list,clist); - if (besttrack->GetConstrain()&&besttrack->GetChi2MIP(0)GetChi2MIP(1)GetChi2MIP(2)GetChi2MIP(3)GetConstrain()&&besttrack->GetChi2MIP(0)GetMaxChi2PerCluster(0)&&besttrack->GetChi2MIP(1)GetMaxChi2PerCluster(1) + &&besttrack->GetChi2MIP(2)GetMaxChi2PerCluster(2)&&besttrack->GetChi2MIP(3)GetMaxChi2PerCluster(3)){ RegisterClusterTracks(besttrack,esdindex); } // @@ -2987,9 +2995,7 @@ AliITStrackMI * AliITStrackerMI::GetBestHypothesys(Int_t esdindex, AliITStrackMI } return besttrack; } - - - +//------------------------------------------------------------------------ void AliITStrackerMI::GetBestHypothesysMIP(TObjArray &itsTracks) { // @@ -3070,8 +3076,7 @@ void AliITStrackerMI::GetBestHypothesysMIP(TObjArray &itsTracks) } } } - - +//------------------------------------------------------------------------ void AliITStrackerMI::CookLabel(AliITStrackMI *track,Float_t wrong) const { //-------------------------------------------------------------------- //This function "cooks" a track label. If label<0, this track is fake. @@ -3102,9 +3107,7 @@ void AliITStrackerMI::CookLabel(AliITStrackMI *track,Float_t wrong) const { } } - - - +//------------------------------------------------------------------------ void AliITStrackerMI::CookdEdx(AliITStrackMI* track) { // @@ -3153,8 +3156,7 @@ void AliITStrackerMI::CookdEdx(AliITStrackMI* track) } track->SetdEdx(sumamp/sumweight); } - - +//------------------------------------------------------------------------ void AliITStrackerMI::MakeCoeficients(Int_t ntracks){ // // @@ -3162,8 +3164,7 @@ void AliITStrackerMI::MakeCoeficients(Int_t ntracks){ fCoeficients = new Float_t[ntracks*48]; for (Int_t i=0;iGetXVdef(), + AliITSReconstructor::GetRecoParam()->GetYVdef(), + AliITSReconstructor::GetRecoParam()->GetZVdef()}; + Double_t ers[]={AliITSReconstructor::GetRecoParam()->GetSigmaXVdef(), + AliITSReconstructor::GetRecoParam()->GetSigmaYVdef(), + AliITSReconstructor::GetRecoParam()->GetSigmaZVdef()}; SetVertex(xyz,ers); for (Int_t i=0; iGetXVdef(), + AliITSReconstructor::GetRecoParam()->GetYVdef(), + AliITSReconstructor::GetRecoParam()->GetZVdef()}; + Double_t ers[]={AliITSReconstructor::GetRecoParam()->GetSigmaXVdef(), + AliITSReconstructor::GetRecoParam()->GetSigmaYVdef(), + AliITSReconstructor::GetRecoParam()->GetSigmaZVdef()}; xyz[0]=t.GetX(); xyz[1]=t.GetY(); xyz[2]=t.GetZ(); ers[0]=t.GetSigmaX(); ers[1]=t.GetSigmaY(); ers[2]=t.GetSigmaZ(); SetVertex(xyz,ers); @@ -145,7 +156,12 @@ AliITStrackerV2::AliITStrackerV2(const Char_t *geom) : fConstraint[0]=1; fConstraint[1]=0; - Double_t xyz[]={kXV,kYV,kZV}, ers[]={kSigmaXV,kSigmaYV,kSigmaZV}; + Double_t xyz[]={AliITSReconstructor::GetRecoParam()->GetXVdef(), + AliITSReconstructor::GetRecoParam()->GetYVdef(), + AliITSReconstructor::GetRecoParam()->GetZVdef()}; + Double_t ers[]={AliITSReconstructor::GetRecoParam()->GetSigmaXVdef(), + AliITSReconstructor::GetRecoParam()->GetSigmaYVdef(), + AliITSReconstructor::GetRecoParam()->GetSigmaZVdef()}; SetVertex(xyz,ers); for (Int_t i=0; iGetSigmaZ2(i)); + Double_t dy=7*TMath::Sqrt(track.GetSigmaY2() + AliITSReconstructor::GetRecoParam()->GetSigmaY2(i)); Double_t road=layer.GetRoad(); if (dz*dy>road*road) { Double_t dd=TMath::Sqrt(dz*dy), scz=dz/dd, scy=dy/dd; dz=road*scz; dy=road*scy; } - //Double_t dz=4*TMath::Sqrt(track.GetSigmaZ2() + kSigmaZ2[i]); + //Double_t dz=4*TMath::Sqrt(track.GetSigmaZ2() + AliITSReconstructor::GetRecoParam()->GetSigmaZ2(i)); if (dz < 0.5*TMath::Abs(track.GetTgl())) dz=0.5*TMath::Abs(track.GetTgl()); - if (dz > kMaxRoad) { + if (dz > AliITSReconstructor::GetRecoParam()->GetMaxRoad()) { //Warning("FollowProlongation","too broad road in Z !\n"); return; } if (TMath::Abs(fTrackToFollow.GetZ()-GetZ()) > r+dz) return; - //Double_t dy=4*TMath::Sqrt(track.GetSigmaY2() + kSigmaY2[i]); + //Double_t dy=4*TMath::Sqrt(track.GetSigmaY2() + AliITSReconstructor::GetRecoParam()->GetSigmaY2(i)); if (dy < 0.5*TMath::Abs(track.GetSnp())) dy=0.5*TMath::Abs(track.GetSnp()); - if (dy > kMaxRoad) { + if (dy > AliITSReconstructor::GetRecoParam()->GetMaxRoad()) { //Warning("FollowProlongation","too broad road in Y !\n"); return; } @@ -548,7 +564,7 @@ void AliITStrackerV2::FollowProlongation() { if (ncl) if (ncl >= nclb) { Double_t chi2=fTrackToFollow.GetChi2(); - if (chi2/ncl < kChi2PerCluster) { + if (chi2/ncl < AliITSReconstructor::GetRecoParam()->GetChi2PerCluster()) { if (ncl > nclb || chi2 < fBestTrack.GetChi2()) { ResetBestTrack(); } @@ -566,8 +582,8 @@ Int_t AliITStrackerV2::TakeNextProlongation() { AliITSlayer &layer=fgLayers[fI]; ResetTrackToFollow(fTracks[fI]); - Double_t dz=7*TMath::Sqrt(fTrackToFollow.GetSigmaZ2() + kSigmaZ2[fI]); - Double_t dy=7*TMath::Sqrt(fTrackToFollow.GetSigmaY2() + kSigmaY2[fI]); + Double_t dz=7*TMath::Sqrt(fTrackToFollow.GetSigmaZ2() + AliITSReconstructor::GetRecoParam()->GetSigmaZ2(fI)); + Double_t dy=7*TMath::Sqrt(fTrackToFollow.GetSigmaY2() + AliITSReconstructor::GetRecoParam()->GetSigmaY2(fI)); Double_t road=layer.GetRoad(); if (dz*dy>road*road) { Double_t dd=TMath::Sqrt(dz*dy), scz=dz/dd, scy=dy/dd; @@ -576,7 +592,7 @@ Int_t AliITStrackerV2::TakeNextProlongation() { const AliITSRecPoint *c=0; Int_t ci=-1; const AliITSRecPoint *cc=0; Int_t cci=-1; - Double_t chi2=kMaxChi2; + Double_t chi2=AliITSReconstructor::GetRecoParam()->GetMaxChi2(); while ((c=layer.GetNextCluster(ci))!=0) { Int_t idet=c->GetDetectorIndex(); @@ -1041,7 +1057,7 @@ Bool_t AliITStrackerV2::RefitAt(Double_t xx,AliITStrackV2 *t, t->SetDetectorIndex(idet); const AliITSRecPoint *cl=0; - Double_t maxchi2=kMaxChi2; + Double_t maxchi2=AliITSReconstructor::GetRecoParam()->GetMaxChi2(); Int_t idx=index[i]; if (idx>=0) { @@ -1081,9 +1097,9 @@ Bool_t AliITStrackerV2::RefitAt(Double_t xx,AliITStrackV2 *t, if (extra) { //search for extra clusters AliITStrackV2 tmp(*t); - Double_t dz=4*TMath::Sqrt(tmp.GetSigmaZ2()+kSigmaZ2[i]); + Double_t dz=4*TMath::Sqrt(tmp.GetSigmaZ2()+AliITSReconstructor::GetRecoParam()->GetSigmaZ2(i)); if (dz < 0.5*TMath::Abs(tmp.GetTgl())) dz=0.5*TMath::Abs(tmp.GetTgl()); - Double_t dy=4*TMath::Sqrt(t->GetSigmaY2()+kSigmaY2[i]); + Double_t dy=4*TMath::Sqrt(t->GetSigmaY2()+AliITSReconstructor::GetRecoParam()->GetSigmaY2(i)); if (dy < 0.5*TMath::Abs(tmp.GetSnp())) dy=0.5*TMath::Abs(tmp.GetSnp()); Double_t zmin=t->GetZ() - dz; Double_t zmax=t->GetZ() + dz; @@ -1092,7 +1108,7 @@ Bool_t AliITStrackerV2::RefitAt(Double_t xx,AliITStrackV2 *t, layer.SelectClusters(zmin,zmax,ymin,ymax); const AliITSRecPoint *c=0; Int_t ci=-1,cci=-1; - Double_t maxchi2=1000.*kMaxChi2, tolerance=0.1; + Double_t maxchi2=1000.*AliITSReconstructor::GetRecoParam()->GetMaxChi2(), tolerance=0.1; while ((c=layer.GetNextCluster(ci))!=0) { if (idet == c->GetDetectorIndex()) continue; diff --git a/ITS/AliITStrackerV2.h b/ITS/AliITStrackerV2.h index f2f9cc56cc1..a79ff5af5b7 100644 --- a/ITS/AliITStrackerV2.h +++ b/ITS/AliITStrackerV2.h @@ -9,7 +9,7 @@ // Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch //------------------------------------------------------------------------- #include "AliTracker.h" -#include "AliITSrecoV2.h" +#include "AliITSRecoParam.h" #include "AliITStrackV2.h" class AliITSRecPoint; diff --git a/ITS/ITSrecLinkDef.h b/ITS/ITSrecLinkDef.h index f89df81a3a1..b61b11f2671 100644 --- a/ITS/ITSrecLinkDef.h +++ b/ITS/ITSrecLinkDef.h @@ -60,6 +60,7 @@ #pragma link C++ class AliITStrackSA+; #pragma link C++ class AliITSVertexerFast+; #pragma link C++ class AliITSReconstructor+; +#pragma link C++ class AliITSRecoParam+; #pragma link C++ class AliITSClusterFinderV2+; #pragma link C++ class AliITSClusterFinderV2SDD+; #pragma link C++ class AliITSClusterFinderV2SPD+; diff --git a/ITS/libITSrec.pkg b/ITS/libITSrec.pkg index 394775c2252..ef15729de1d 100644 --- a/ITS/libITSrec.pkg +++ b/ITS/libITSrec.pkg @@ -44,6 +44,7 @@ SRCS = AliITSDetTypeRec.cxx \ AliITSRawClusterSDD.cxx \ AliITSRawClusterSSD.cxx\ AliITSReconstructor.cxx \ + AliITSRecoParam.cxx \ AliITSBeamTestDig.cxx \ AliITSBeamTestDigSDD.cxx \ AliITSBeamTestDigSPD.cxx \ @@ -83,4 +84,4 @@ DHDR=ITSrecLinkDef.h EINCLUDE:=TPC RAW EXPORT:=AliITStrackV2.h \ - AliITSVertexer.h AliITSrecoV2.h + AliITSVertexer.h AliITSRecoParam.h -- 2.43.0