From 7167ae53fb865b9b542e5fb52358aebfc74e405e Mon Sep 17 00:00:00 2001 From: hristov Date: Wed, 23 Jan 2008 08:35:52 +0000 Subject: [PATCH] Plane efficiency framework (Guiseppe) --- ITS/AliITSPlaneEff.cxx | 28 ++- ITS/AliITSPlaneEff.h | 12 +- ITS/AliITSPlaneEffSDD.cxx | 176 +++++++++++++++--- ITS/AliITSPlaneEffSDD.h | 16 +- ITS/AliITSPlaneEffSPD.cxx | 104 ++++++++--- ITS/AliITSPlaneEffSPD.h | 12 +- ITS/AliITSPlaneEffSSD.cxx | 59 +++--- ITS/AliITSPlaneEffSSD.h | 8 + ITS/AliITStrackerMI.cxx | 167 ++++++++++++++++- ITS/AliITStrackerMI.h | 11 +- ITS/MakeITSPlaneEfficiencySDD.C | 20 +- ITS/MakeITSPlaneEfficiencySPD.C | 48 +++-- ITS/MakeITSPlaneEfficiencySSD.C | 19 +- .../PlaneEffSDD/Run0_999999999_v0_s0.root | Bin 4651 -> 4720 bytes .../PlaneEffSPD/Run0_999999999_v0_s0.root | Bin 3819 -> 3888 bytes .../PlaneEffSSD/Run0_999999999_v0_s0.root | Bin 4292 -> 4362 bytes STEER/AliPlaneEff.cxx | 89 +++++++++ STEER/AliPlaneEff.h | 54 ++++++ STEER/AliReconstruction.cxx | 60 +++++- STEER/AliReconstruction.h | 9 + STEER/AliTracker.h | 2 + STEER/STEERLinkDef.h | 4 + STEER/libSTEER.pkg | 5 +- 23 files changed, 787 insertions(+), 116 deletions(-) create mode 100644 STEER/AliPlaneEff.cxx create mode 100644 STEER/AliPlaneEff.h diff --git a/ITS/AliITSPlaneEff.cxx b/ITS/AliITSPlaneEff.cxx index ae8af5b74df..b5bda20f9ec 100644 --- a/ITS/AliITSPlaneEff.cxx +++ b/ITS/AliITSPlaneEff.cxx @@ -34,7 +34,7 @@ ClassImp(AliITSPlaneEff) //______________________________________________________________________ -AliITSPlaneEff::AliITSPlaneEff(): TObject(), +AliITSPlaneEff::AliITSPlaneEff(): AliPlaneEff(), fRunNumber(0), fCDBUri(""), fInitCDBCalled(kFALSE) @@ -49,7 +49,7 @@ fInitCDBCalled(kFALSE) InitCDB(); } //______________________________________________________________________ -AliITSPlaneEff::AliITSPlaneEff(const AliITSPlaneEff &s) : TObject(s), +AliITSPlaneEff::AliITSPlaneEff(const AliITSPlaneEff &s) : AliPlaneEff(s), fRunNumber(s.fRunNumber), fCDBUri(s.fCDBUri), fInitCDBCalled(s.fInitCDBCalled) @@ -90,13 +90,25 @@ AliITSPlaneEff& AliITSPlaneEff::operator=(const AliITSPlaneEff &source){ source.Copy(*this); } return *this; -// if(&s == this) return *this; -// this->fRunNumber = s.fRunNumber; -// this->fCDBUri = s.fCDBUri; -// this->fInitCDBCalled = s.fInitCDBCalled; -// return *this; } -//_____________________________________________________________ +//_________________________________________________________________________ +/* +AliPlaneEff& AliITSPlaneEff::operator=(const + AliPlaneEff &s){ + // Assignment operator + // Inputs: + // AliPlaneEff &s The original class for which + // this class is a copy of + // Outputs: + // none. + // Return: + + if(&s == this) return *this; + AliWarning("AliITSPlaneEff Not allowed to make a = Using default creator instead"); + return *this; +} +*/ +//_________________________________________________________________________ void AliITSPlaneEff::Copy(TObject &obj) const { // copy this to obj ((AliITSPlaneEff& ) obj).fRunNumber = fRunNumber; diff --git a/ITS/AliITSPlaneEff.h b/ITS/AliITSPlaneEff.h index cd69a6f7974..5715c88b347 100644 --- a/ITS/AliITSPlaneEff.h +++ b/ITS/AliITSPlaneEff.h @@ -3,8 +3,8 @@ /* Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. * * See cxx source for full Copyright notice */ -#include #include +#include "AliPlaneEff.h" #include "AliLog.h" class AliITSsegmentation; @@ -20,12 +20,11 @@ class AliITSgeom; /* $Id$ */ -class AliITSPlaneEff : public TObject { +class AliITSPlaneEff : public AliPlaneEff { public: AliITSPlaneEff();// Default constructor // Standard constructor - //AliITSPlaneEff(AliITSDetTypeSim *dettyp); virtual ~AliITSPlaneEff(){;}; // copy constructor. See detector specific implementation. AliITSPlaneEff(const AliITSPlaneEff &source); @@ -41,6 +40,8 @@ class AliITSPlaneEff : public TObject { Double_t ErrPlaneEff(Int_t nfound,Int_t ntried) const; virtual void GetPlaneEff(Int_t nfound,Int_t ntried,Double_t &eff, Double_t &err) const {eff=PlaneEff(nfound,ntried); err=ErrPlaneEff(nfound,ntried); return;}; + // + virtual Double_t PlaneEff(const UInt_t key) const=0; // Plane efficiency for active detector (excluding dead/noisy channels) virtual Double_t LivePlaneEff(UInt_t) const {AliWarning("This method gives just a rough estimate of the live-Det Efficiency!"); @@ -66,6 +67,11 @@ class AliITSPlaneEff : public TObject { {AliError("This method must be implemented in a derived class"); return kFALSE;}; virtual Bool_t AddFromCDB() {AliError("This method must be implemented in a derived class"); return kFALSE;}; + // method to locate a basic block from Detector Local coordinate + virtual UInt_t GetKeyFromDetLocCoord(Int_t, Int_t, Float_t, Float_t) const + {AliError("This method must be implemented in a derived class"); return 999999;}; + virtual UInt_t Nblock() const // return the number of basic blocks + {AliError("This method must be implemented in a derived class"); return 999999;}; protected: diff --git a/ITS/AliITSPlaneEffSDD.cxx b/ITS/AliITSPlaneEffSDD.cxx index 93acd530ceb..20424b1e219 100644 --- a/ITS/AliITSPlaneEffSDD.cxx +++ b/ITS/AliITSPlaneEffSDD.cxx @@ -14,8 +14,8 @@ **************************************************************************/ /////////////////////////////////////////////////////////////////////////// // Plane Efficiency class for ITS -// It is used for chip by chip efficiency (eventually with subwing division -// along the drift direction ) of the SDD, +// It is used for chip by chip efficiency (eventually with sui-bwing division +// along the drift direction) of the SDD, // evaluated by tracks // (Inherits from AliITSPlaneEff) // Author: G.E. Bruno @@ -32,13 +32,14 @@ #include "AliCDBEntry.h" #include "AliCDBManager.h" //#include "AliCDBRunRange.h" +#include "AliITSgeom.h" #include "AliITSCalibrationSDD.h" +#include "AliITSsegmentationSDD.h" ClassImp(AliITSPlaneEffSDD) //______________________________________________________________________ AliITSPlaneEffSDD::AliITSPlaneEffSDD(): AliITSPlaneEff(){ - // Default constructor for (UInt_t i=0; i=kNModule || ic>=kNChip || iw>=kNWing || is>=kNSubWing) - {Error("AliITSPlaneEffSDD","you asked for a non existing block"); + {AliError("GetMissingTracksForGivenEff: you asked for a non existing block"); return -1;} else return GetNTracksForGivenEff(eff,RelErr)-fTried[GetKey(im,ic,iw,is)]; } @@ -161,7 +160,7 @@ Double_t AliITSPlaneEffSDD::PlaneEff(const UInt_t im,const UInt_t ic, // iw -> wing number [0,1] // is -> chip number [0,kNSubWing-1] if (im>=kNModule || ic>=kNChip || iw>=kNWing || is>=kNSubWing) - {Error("AliITSPlaneEffSDD","you asked for a non existing block"); return -1.;} + {AliError("PlaneEff(UInt_t,UInt_t,UInt_t,UInt_t): you asked for a non existing block"); return -1.;} Int_t nf=fFound[GetKey(im,ic,iw,is)]; Int_t nt=fTried[GetKey(im,ic,iw,is)]; return AliITSPlaneEff::PlaneEff(nf,nt); @@ -177,7 +176,7 @@ Double_t AliITSPlaneEffSDD::ErrPlaneEff(const UInt_t im,const UInt_t ic, // iw -> wing number [0,1] // is -> chip number [0,kNSubWing-1] if (im>=kNModule || ic>=kNChip || iw>=kNWing || is>=kNSubWing) - {Error("AliITSPlaneEffSDD","you asked for a non existing block"); return -1.;} + {AliError("ErrPlaneEff(UInt_t,UInt_t,UInt_t,UInt_t): you asked for a non existing block"); return -1.;} Int_t nf=fFound[GetKey(im,ic,iw,is)]; Int_t nt=fTried[GetKey(im,ic,iw,is)]; return AliITSPlaneEff::ErrPlaneEff(nf,nt); @@ -188,7 +187,7 @@ Bool_t AliITSPlaneEffSDD::UpDatePlaneEff(const Bool_t Kfound, const UInt_t iw, const UInt_t is) { // Update efficiency for a basic block if (im>=kNModule || ic>=kNChip || iw>=kNWing || is>=kNSubWing) - {Error("AliITSPlaneEffSDD","you asked for a non existing block"); return kFALSE;} + {AliError("UpDatePlaneEff: you asked for a non existing block"); return kFALSE;} fTried[GetKey(im,ic,iw,is)]++; if(Kfound) fFound[GetKey(im,ic,iw,is)]++; return kTRUE; @@ -199,7 +198,7 @@ void AliITSPlaneEffSDD::ChipAndWingFromAnode(const UInt_t anode, UInt_t& chip, // Retun the chip number [0,3] and the wing number [0,1] given the anode number // input: anode number [0,511] if(anode>=kNAnode*kNChip*kNWing) - {Error("AliITSPlaneEffSDD::ChipAndWingFromAnode","you asked for a non existing anode"); + {AliError("ChipAndWingFromAnode: you asked for a non existing anode"); chip=999; wing=99; return;} @@ -214,7 +213,7 @@ UInt_t AliITSPlaneEffSDD::ChipFromAnode(const UInt_t anode) const { // Retun the chip number [0,3] given the anode number // input: anode number [0,511] if(anode>=kNAnode*kNChip*kNWing) - {Error("AliITSPlaneEffSDD::ChipFromAnode","you asked for a non existing anode"); return 999;} + {AliError("ChipFromAnode: you asked for a non existing anode"); return 999;} Int_t wing=0; Int_t chip=anode/kNAnode; if(anode>=kNChip*kNAnode) wing=1; @@ -226,7 +225,7 @@ UInt_t AliITSPlaneEffSDD::WingFromAnode(const UInt_t anode) const { // return the wing number [0,1] given the anode number // input: anode number [0,511] if(anode>=kNAnode*kNChip*kNWing) - {Error("AliITSPlaneEffSDD::GetWingFromAnode","you asked for a non existing anode"); return 99;} + {AliError("WingFromAnode: you asked for a non existing anode"); return 99;} Int_t wing=0; if(anode>=kNChip*kNAnode) wing=1; return wing; @@ -236,35 +235,35 @@ UInt_t AliITSPlaneEffSDD::GetKey(const UInt_t mod, const UInt_t chip, const UInt_t wing, const UInt_t subw) const { // get key given a basic block if(mod>=kNModule || chip>=kNChip || wing>= kNWing || subw>=kNSubWing) - {Error("AliITSPlaneEffSDD::GetKey","you asked for a non existing block"); return 99999;} + {AliError("GetKey: you asked for a non existing block"); return 99999;} return mod*kNChip*kNWing*kNSubWing+chip*kNWing*kNSubWing+wing*kNSubWing+subw; } //__________________________________________________________________________ UInt_t AliITSPlaneEffSDD::GetModFromKey(const UInt_t key) const { // get mod. from key if(key>=kNModule*kNChip*kNWing*kNSubWing) - {Error("AliITSPlaneEffSDD::GetModFromKey","you asked for a non existing key"); return 9999;} + {AliError("GetModFromKey: you asked for a non existing key"); return 9999;} return key/(kNChip*kNWing*kNSubWing); } //__________________________________________________________________________ UInt_t AliITSPlaneEffSDD::GetChipFromKey(const UInt_t key) const { // retrieves chip from key if(key>=kNModule*kNChip*kNWing*kNSubWing) - {Error("AliITSPlaneEffSDD::GetChipFromKey","you asked for a non existing key"); return 999;} + {AliError("GetChipFromKey: you asked for a non existing key"); return 999;} return (key%(kNChip*kNWing*kNSubWing))/(kNWing*kNSubWing); } //__________________________________________________________________________ UInt_t AliITSPlaneEffSDD::GetWingFromKey(const UInt_t key) const { // retrieves wing from key if(key>=kNModule*kNChip*kNWing*kNSubWing) - {Error("AliITSPlaneEffSDD::GetWingFromKey","you asked for a non existing key"); return 99;} + {AliError("GetWingFromKey: you asked for a non existing key"); return 99;} return ((key%(kNChip*kNWing*kNSubWing))%(kNWing*kNSubWing))/(kNSubWing); } //__________________________________________________________________________ UInt_t AliITSPlaneEffSDD::GetSubWingFromKey(const UInt_t key) const { // retrieves sub-wing from key if(key>=kNModule*kNChip*kNWing*kNSubWing) - {Error("AliITSPlaneEffSDD::GetSubWingFromKey","you asked for a non existing key"); return 9;} + {AliError("GetSubWingFromKey: you asked for a non existing key"); return 9;} return ((key%(kNChip*kNWing*kNSubWing))%(kNWing*kNSubWing))%(kNSubWing); } //__________________________________________________________________________ @@ -272,7 +271,7 @@ void AliITSPlaneEffSDD::GetAllFromKey(const UInt_t key,UInt_t& mod,UInt_t& chip, UInt_t& wing,UInt_t& subw) const { // get module, chip, wing and subwing from a key if(key>=kNModule*kNChip*kNWing*kNSubWing) - {Error("AliITSPlaneEffSDD::GetAllFromKey","you asked for a non existing key"); + {AliError("GetAllFromKey: you asked for a non existing key"); mod=9999; chip=999; wing=99; @@ -288,7 +287,7 @@ return; Double_t AliITSPlaneEffSDD::LivePlaneEff(UInt_t key) const { // returns plane efficieny after adding the fraction of sensor which is bad if(key>=kNModule*kNChip*kNWing*kNSubWing) - {Error("AliITSPlaneEffSDD::LivePlaneEff","you asked for a non existing key"); + {AliError("LivePlaneEff: you asked for a non existing key"); return -1.;} Double_t leff=AliITSPlaneEff::LivePlaneEff(0); // this just for the Warning leff=PlaneEff(key)+GetFracBad(key); @@ -298,7 +297,7 @@ return leff>1?1:leff; Double_t AliITSPlaneEffSDD::ErrLivePlaneEff(UInt_t key) const { // returns error on live plane efficiency if(key>=kNModule*kNChip*kNWing*kNSubWing) - {Error("AliITSPlaneEffSDD::ErrLivePlaneEff","you asked for a non existing key"); + {AliError("ErrLivePlaneEff: you asked for a non existing key"); return -1.;} Int_t nf=fFound[key]; Double_t triedInLive=GetFracLive(key)*fTried[key]; @@ -309,7 +308,7 @@ return AliITSPlaneEff::ErrPlaneEff(nf,nt); // for the time being: to be checked Double_t AliITSPlaneEffSDD::GetFracLive(const UInt_t key) const { // returns the fraction of the sensor which is OK if(key>=kNModule*kNChip*kNWing*kNSubWing) - {Error("AliITSPlaneEffSDD::GetFracLive","you asked for a non existing key"); + {AliError("GetFracLive: you asked for a non existing key"); return -1.;} // Compute the fraction of bad (dead+noisy) detector UInt_t bad=0; @@ -324,11 +323,11 @@ void AliITSPlaneEffSDD::GetBadInBlock(const UInt_t key, UInt_t& nrBadInBlock) co // (it depends on the chip, not on the sub-wing) nrBadInBlock=0; if(key>=kNModule*kNChip*kNWing*kNSubWing) - {Error("AliITSPlaneEffSDD::GetBadInBlock","you asked for a non existing key"); + {AliError("GetBadInBlock: you asked for a non existing key"); return;} // if(!fInitCDBCalled) - {Error("AliITSPlaneEffSDD::GetBadInBlock","CDB not inizialized: call InitCDB first"); + {AliError("GetBadInBlock: CDB not inizialized: call InitCDB first"); return;}; AliCDBManager* man = AliCDBManager::Instance(); // retrieve map of dead Pixel @@ -337,10 +336,10 @@ TObjArray* sddEntry; if(cdbSDD) { sddEntry = (TObjArray*)cdbSDD->GetObject(); if(!sddEntry) - {Error("AliITSPlaneEffSDD::GetBadInBlock"," SDDEntry not found in CDB"); + {AliError("GetBadInBlock: SDDEntry not found in CDB"); return;} } else { - Error("AliITSPlaneEffSDD::GetBadInBlock","Did not find Calib/CalibSDD"); + AliError("GetBadInBlock: Did not find Calib/CalibSDD"); return; } // @@ -360,7 +359,7 @@ return; Double_t AliITSPlaneEffSDD::GetFracBad(const UInt_t key) const { // returns 1-fractional live if(key>=kNModule*kNChip*kNWing*kNSubWing) - {Error("AliITSPlaneEffSDD::GetFracBad","you asked for a non existing key"); + {AliError("GetFracBad: you asked for a non existing key"); return -1.;} return 1.-GetFracLive(key); } @@ -368,7 +367,7 @@ return 1.-GetFracLive(key); Bool_t AliITSPlaneEffSDD::WriteIntoCDB() const { // write onto CDB if(!fInitCDBCalled) - {Error("AliITSPlaneEffSDD::WriteIntoCDB","CDB not inizialized: call InitCDB first"); + {AliError("WriteIntoCDB: CDB not inizialized: call InitCDB first"); return kFALSE;} // to be written properly: now only for debugging AliCDBMetaData *md= new AliCDBMetaData(); // metaData describing the object @@ -387,7 +386,7 @@ if(!fInitCDBCalled) Bool_t AliITSPlaneEffSDD::ReadFromCDB() { // read from CDB if(!fInitCDBCalled) - {Error("AliITSPlaneEffSDD::ReadFromCDB","CDB not inizialized: call InitCDB first"); + {AliError("ReadFromCDB: CDB not inizialized: call InitCDB first"); return kFALSE;} //if(!AliCDBManager::Instance()->IsDefaultStorageSet()) { // AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT"); @@ -398,3 +397,122 @@ if(this==eff) return kFALSE; eff->Copy(*this); return kTRUE; } +//_____________________________________________________________________________ +UInt_t AliITSPlaneEffSDD::GetKeyFromDetLocCoord(Int_t ilay, Int_t idet, + Float_t locx, Float_t locz) const { +// method to locate a basic block from Detector Local coordinate (to be used in tracking) +// +// If kNSubWing = 1, i.e. no sub-wing subdivision, then the numbering scheme of the +// unique key is the following, e.g. for the first detector (idet=0, ilayer=2) +// +// ^x_loc (cm) +// | +// _________________________|__________________________ 3.5085 +// | | | | | +// | | | | | +// | | | | | +// | key=1 | key=3 | key=5 | key=7 | +// | | | | | +// |____________|____________|____________|____________|_0_____\ local z (cm) +// | | | | | / +// | | | | | +// | key=0 | key=2 | key=4 | key=6 | +// | | | | | +// | | | | | +// |____________|____________|____________|____________| -3.5085 +//-3.7632 -1.8816 0 1.1186 3.7632 +// +// for the second detector (idet=2, ilay=2), first key is 8 (bottom-left), +// last one is 15 (upper-right), and so on. +// +// If subwing division has been applied, then you count in each wing, starting from +// the one with negative local , from the anode side (outer part) towards the +// cathod strip (center). +// first column: +// bottom wing (from below): 0,1,..,kNSubWing-1, +// upper wing (from up): kNSubWing, ... , 2*kNSubWing-1 +// 2nd column +// bottom wing (from below): 2*kNSubWing, .. , 3*kNSubWing-1 +// upper wing (from up): 3*kNSubWing, ... ,4*kNSubWing-1 +// ... +// 4nd (last) column : +// bottom wing (from below): 6*kNSubWing, .. , 7*kNSubWing-1 +// upper wing (from up): 7*kNSubWing, ... ,8*kNSubWing-1 +// +// E.g. kNSubWing=2. +// +// ^x_loc (cm) +// | +// _________________________|__________________________ 3.5085 +// | | | | | +// | key=2 | key=6 | key=10 | key=14 | +// |____________|____________|____________|____________| +// | | | | | +// | key=3 | key=7 | key=11 | key=15 | +// |____________|____________|____________|____________|_0_____\ local z (cm) +// | | | | | / +// | key=1 | key=5 | key=9 | key=13 | +// |____________|____________|____________|____________| +// | | | | | +// | key=0 | key=4 | key=8 | key=12 | +// |____________|____________|____________|____________| -3.5085 +//-3.7632 -1.8816 0 1.1186 3.7632 +// +//___________________________________________________________________________ +// +UInt_t key=999999; +if(ilay<2 || ilay>3) + {AliError("GetKeyFromDetLocCoord: you asked for a non existing layer"); + return key;} +if(ilay==2 && (idet<0 || idet>83)) + {AliError("GetKeyFromDetLocCoord: you asked for a non existing detector"); + return key;} +if(ilay==3 && (idet<0 || idet>175)) + {AliError("GetKeyFromDetLocCoord: you asked for a non existing detector"); + return key;} +UInt_t mod=idet; +if(ilay==3) mod+=84; +UInt_t chip=0,wing=0,subw=0; +ChipAndWingAndSubWingFromLocCoor(locx,locz,chip,wing,subw); +key=GetKey(mod,chip,wing,subw); +return key; +} +//_____________________________________________________________________________ +void AliITSPlaneEffSDD::ChipAndWingAndSubWingFromLocCoor(Float_t xloc, Float_t zloc, + UInt_t& chip, UInt_t& wing, UInt_t& subw) const { +AliITSgeom* geom=NULL; +//AliITSsegmentationSDD* sdd=new AliITSsegmentationSDD(geom); +AliITSsegmentationSDD sdd=AliITSsegmentationSDD(geom); +sdd.SetDriftSpeed(sdd.GetDriftSpeed()); // this only for setting fSetDriftSpeed=kTRUE !!! +Int_t ix,iz; +Int_t ntb; +UInt_t anode=0; +if(sdd.LocalToDet(xloc,zloc,ix,iz)) { + anode+=iz; + ChipAndWingFromAnode(anode,chip,wing); + if(sdd.LocalToDet(0.,0.,ntb,iz)) { // in this way the sub-division along time coordinate + subw=SubWingFromTimeBin(ix,ntb); } // is purely geometrical one and it does not + else { // depen on the drift-velocity. + AliError("ChipAndWingAndSubWingFromLocCoor: cannot calculate n. of time bins for SubWing."); + subw=9; + } +} else { + AliError("ChipAndWingAndSubWingFromLocCoor: cannot calculate anode number and time bin."); + chip=999; + wing=99; + subw=9; +} +delete geom; +} +//__________________________________________________________________________________ +UInt_t AliITSPlaneEffSDD::SubWingFromTimeBin(const Int_t tb, const Int_t ntb) const { +if(tb<0 || tb>ntb || ntb<0) { + AliError(Form("SubWingFromTimeBin: you asked time bin = %d with %d n. of bins",tb,ntb)); + return 9; +} +//AliDebug(Form("tb = %d, ntb= %d , NSubWing = %d",tb,ntb,kNSubWing)); +Float_t h=tb; + h/=ntb; + h*=(kNSubWing-1); +return TMath::Nint(h); +} diff --git a/ITS/AliITSPlaneEffSDD.h b/ITS/AliITSPlaneEffSDD.h index fb785443416..ef78465116f 100644 --- a/ITS/AliITSPlaneEffSDD.h +++ b/ITS/AliITSPlaneEffSDD.h @@ -50,7 +50,7 @@ class AliITSPlaneEffSDD : public AliITSPlaneEff { enum {kNSubWing = 1}; // Eventually sub-divide each wing (by 2 ?) to account for different // efficiencies due to different drift times. enum {kNAnode = 64}; // Number of channels/chip (i.e. anodes per chip) - enum {kNTimeBin = 72}; // granularity along drift direction (i.e. segmentation in r-phi) + //enum {kNTimeBin = 174}; // granularity along drift direction (i.e. segmentation in r-phi) // // Plane efficiency for active detector (excluding dead/noisy channels) // access to DB is needed @@ -70,6 +70,11 @@ class AliITSPlaneEffSDD : public AliITSPlaneEff { virtual Bool_t ReadFromCDB(); // this method reads Data Members (statistics) from DataBase virtual Bool_t AddFromCDB() // this method updates Data Members (statistics) from DataBase {AliError("AddFromCDB: Still To be implemented"); return kFALSE;} + // method to locate a basic block from Detector Local coordinate (to be used in tracking) + // see file cxx for numbering convention. + // here idet runs from 0 to 83 for layer 2 and from 0 to 175 for layer 3 + UInt_t GetKeyFromDetLocCoord(Int_t ilay,Int_t idet, Float_t locx, Float_t locz) const; + UInt_t Nblock() const; // return the number of basic blocks protected: virtual void Copy(TObject &obj) const; @@ -89,6 +94,12 @@ class AliITSPlaneEffSDD : public AliITSPlaneEff { UInt_t ChipFromAnode(const UInt_t anode) const; // return the chip number (from 0 to kNChip-1) UInt_t WingFromAnode(const UInt_t anode) const; // return the wing number (from 0 to kNWing-1) void ChipAndWingFromAnode(const UInt_t anode,UInt_t& chip,UInt_t& wing) const; + // return the Subwing (from 0 to kNSubWing-1) from the cell time bin in the range + // [0,ntb] and from the number of time bins + UInt_t SubWingFromTimeBin(const Int_t tb, const Int_t ntb) const; + + void ChipAndWingAndSubWingFromLocCoor(Float_t locx, Float_t locz, + UInt_t& chip, UInt_t& wing, UInt_t& subw) const; // void GetAllFromKey(const UInt_t key, UInt_t& mod, UInt_t& chip, UInt_t& wing, UInt_t& subw) const; @@ -96,5 +107,8 @@ class AliITSPlaneEffSDD : public AliITSPlaneEff { ClassDef(AliITSPlaneEffSDD,1) // SDD Plane Efficiency class }; +// +inline UInt_t AliITSPlaneEffSDD::Nblock() const {return kNModule*kNChip*kNWing*kNSubWing;} +// #endif diff --git a/ITS/AliITSPlaneEffSPD.cxx b/ITS/AliITSPlaneEffSPD.cxx index f41c9b5e830..26eca728b12 100644 --- a/ITS/AliITSPlaneEffSPD.cxx +++ b/ITS/AliITSPlaneEffSPD.cxx @@ -31,6 +31,7 @@ #include "AliCDBEntry.h" #include "AliCDBManager.h" //#include "AliCDBRunRange.h" +//#include "AliITSsegmentationSPD.h" #include "AliITSCalibrationSPD.h" ClassImp(AliITSPlaneEffSPD) @@ -129,9 +130,7 @@ AliITSPlaneEff& AliITSPlaneEffSPD::operator=(const // Return: if(&s == this) return *this; - Error("AliITSPlaneEffSPD","Not allowed to make a = with " - "AliITSPlaneEffSPD","Using default creater instead"); - + AliError("operator=: Not allowed to make a =, use default creater instead"); return *this; } //_______________________________________________________________________ @@ -149,7 +148,7 @@ Int_t AliITSPlaneEffSPD::GetMissingTracksForGivenEff(Double_t eff, Double_t RelE // Return: the estimated n. of tracks // if (im>=kNModule || ic>=kNChip) - {Error("AliITSPlaneEffSPD","you asked for a non existing chip"); + {AliError("GetMissingTracksForGivenEff: you asked for a non existing chip"); return -1;} else return GetNTracksForGivenEff(eff,RelErr)-fTried[GetKey(im,ic)]; } @@ -160,7 +159,7 @@ Double_t AliITSPlaneEffSPD::PlaneEff(const UInt_t im,const UInt_t ic) const { // im -> module number [0,249] // ic -> chip number [0,4] if (im>=kNModule || ic>=kNChip) - {Error("AliITSPlaneEffSPD","you asked for a non existing chip"); return -1.;} + {AliError("PlaneEff(Uint_t,Uint_t): you asked for a non existing chip"); return -1.;} Int_t nf=fFound[GetKey(im,ic)]; Int_t nt=fTried[GetKey(im,ic)]; return AliITSPlaneEff::PlaneEff(nf,nt); @@ -173,7 +172,7 @@ Double_t AliITSPlaneEffSPD::ErrPlaneEff(const UInt_t im,const UInt_t ic) const // im -> module number [0,249] // ic -> chip number [0,4] if (im>=kNModule || ic>=kNChip) - {Error("AliITSPlaneEffSPD","you asked for a non existing chip"); return -1.;} + {AliError("ErrPlaneEff(Uint_t,Uint_t): you asked for a non existing chip"); return -1.;} Int_t nf=fFound[GetKey(im,ic)]; Int_t nt=fTried[GetKey(im,ic)]; return AliITSPlaneEff::ErrPlaneEff(nf,nt); @@ -183,7 +182,7 @@ Bool_t AliITSPlaneEffSPD::UpDatePlaneEff(const Bool_t Kfound, const UInt_t im, const UInt_t ic) { // Update efficiency for a basic block if (im>=kNModule || ic>=kNChip) - {Error("AliITSPlaneEffSPD","you asked for a non existing chip"); return kFALSE;} + {AliError("UpDatePlaneEff: you asked for a non existing chip"); return kFALSE;} fTried[GetKey(im,ic)]++; if(Kfound) fFound[GetKey(im,ic)]++; return kTRUE; @@ -192,35 +191,35 @@ if (im>=kNModule || ic>=kNChip) UInt_t AliITSPlaneEffSPD::GetChipFromCol(const UInt_t col) const { // get chip given the column if(col>=kNCol*kNChip) - {Error("AliITSPlaneEffSPD","you asked for a non existing column"); return 10;} + {AliDebug(1,Form("GetChipFromCol: you asked for a non existing column %d",col)); return 10;} return col/kNCol; } //__________________________________________________________________________ UInt_t AliITSPlaneEffSPD::GetKey(const UInt_t mod, const UInt_t chip) const { // get key given a basic block if(mod>=kNModule || chip>=kNChip) - {Error("AliITSPlaneEffSPD::GetKey","you asked for a non existing block"); return 99999;} + {AliWarning("GetKey: you asked for a non existing block"); return 99999;} return mod*kNChip+chip; } //__________________________________________________________________________ UInt_t AliITSPlaneEffSPD::GetModFromKey(const UInt_t key) const { // get mod. from key if(key>=kNModule*kNChip) - {Error("AliITSPlaneEffSPD::GetModFromKey","you asked for a non existing key"); return 9999;} + {AliError("GetModFromKey: you asked for a non existing key"); return 9999;} return key/kNChip; } //__________________________________________________________________________ UInt_t AliITSPlaneEffSPD::GetChipFromKey(const UInt_t key) const { // retrieves chip from key if(key>=kNModule*kNChip) - {Error("AliITSPlaneEffSPD::GetChipFromKey","you asked for a non existing key"); return 999;} + {AliError("GetChipFromKey: you asked for a non existing key"); return 999;} return (key%(kNModule*kNChip))%kNChip; } //__________________________________________________________________________ void AliITSPlaneEffSPD::GetModAndChipFromKey(const UInt_t key,UInt_t& mod,UInt_t& chip) const { // get module and chip from a key if(key>=kNModule*kNChip) - {Error("AliITSPlaneEffSPD::GetModAndChipFromKey","you asked for a non existing key"); + {AliError("GetModAndChipFromKey: you asked for a non existing key"); mod=9999; chip=999; return;} @@ -232,7 +231,7 @@ return; Double_t AliITSPlaneEffSPD::LivePlaneEff(UInt_t key) const { // returns plane efficieny after adding the fraction of sensor which is bad if(key>=kNModule*kNChip) - {Error("AliITSPlaneEffSPD::LivePlaneEff","you asked for a non existing key"); + {AliError("LivePlaneEff: you asked for a non existing key"); return -1.;} Double_t leff=AliITSPlaneEff::LivePlaneEff(0); // this just for the Warning leff=PlaneEff(key)+GetFracBad(key); @@ -242,7 +241,7 @@ return leff>1?1:leff; Double_t AliITSPlaneEffSPD::ErrLivePlaneEff(UInt_t key) const { // returns error on live plane efficiency if(key>=kNModule*kNChip) - {Error("AliITSPlaneEffSPD::ErrLivePlaneEff","you asked for a non existing key"); + {AliError("ErrLivePlaneEff: you asked for a non existing key"); return -1.;} Int_t nf=fFound[key]; Double_t triedInLive=GetFracLive(key)*fTried[key]; @@ -253,7 +252,7 @@ return AliITSPlaneEff::ErrPlaneEff(nf,nt); // for the time being: to be checked Double_t AliITSPlaneEffSPD::GetFracLive(const UInt_t key) const { // returns the fraction of the sensor which is OK if(key>=kNModule*kNChip) - {Error("AliITSPlaneEffSPD::GetFracLive","you asked for a non existing key"); + {AliError("GetFracLive: you asked for a non existing key"); return -1.;} // Compute the fraction of bad (dead+noisy) detector UInt_t dead=0,noisy=0; @@ -269,12 +268,12 @@ void AliITSPlaneEffSPD::GetDeadAndNoisyInChip(const UInt_t key, nrDeadInChip=0; nrNoisyInChip=0; if(key>=kNModule*kNChip) - {Error("AliITSPlaneEffSPD::GetDeadAndNoisyInChip","you asked for a non existing key"); + {AliError("GetDeadAndNoisyInChip: you asked for a non existing key"); return;} // Compute the number of bad (dead+noisy) pixel in a chip // if(!fInitCDBCalled) - {Error("AliITSPlaneEffSPD::GetDeadAndNoisyInChip","CDB not inizialized: call InitCDB first"); + {AliError("GetDeadAndNoisyInChip: CDB not inizialized: call InitCDB first"); return;}; AliCDBManager* man = AliCDBManager::Instance(); // retrieve map of dead Pixel @@ -283,10 +282,10 @@ TObjArray* spdDead; if(cdbSPDDead) { spdDead = (TObjArray*)cdbSPDDead->GetObject(); if(!spdDead) - {Error("AliITSPlaneEffSPD::GetDeadAndNoisyInChip"," SPDDead not found in CDB"); + {AliError("GetDeadAndNoisyInChip: SPDDead not found in CDB"); return;} } else { - Error("AliITSPlaneEffSPD::GetDeadAndNoisyInChip","Did not find Calib/SPDDead."); + AliError("GetDeadAndNoisyInChip: did not find Calib/SPDDead."); return; } // retrieve map of noisy Pixel @@ -295,10 +294,10 @@ TObjArray* spdNoisy; if(cdbSPDNoisy) { spdNoisy = (TObjArray*)cdbSPDNoisy->GetObject(); if(!spdNoisy) - {Error("AliITSPlaneEffSPD::GetDeadAndNoisyInChip"," SPDNoisy not found in CDB"); + {AliError("GetDeadAndNoisyInChip: SPDNoisy not found in CDB"); return;} } else { - Error("AliITSPlaneEffSPD::GetDeadAndNoisyInChip","Did not find Calib/SPDNoisy."); + AliError("GetDeadAndNoisyInChip: did not find Calib/SPDNoisy."); return; } // @@ -321,7 +320,7 @@ return; Double_t AliITSPlaneEffSPD::GetFracBad(const UInt_t key) const { // returns 1-fractional live if(key>=kNModule*kNChip) - {Error("AliITSPlaneEffSPD::GetFracBad","you asked for a non existing key"); + {AliError("GetFracBad: you asked for a non existing key"); return -1.;} return 1.-GetFracLive(key); } @@ -329,7 +328,7 @@ return 1.-GetFracLive(key); Bool_t AliITSPlaneEffSPD::WriteIntoCDB() const { // write onto CDB if(!fInitCDBCalled) - {Error("AliITSPlaneEffSPD::WriteIntoCDB","CDB not inizialized: call InitCDB first"); + {AliError("WriteIntoCDB: CDB not inizialized. Call InitCDB first"); return kFALSE;} // to be written properly: now only for debugging AliCDBMetaData *md= new AliCDBMetaData(); // metaData describing the object @@ -348,7 +347,7 @@ if(!fInitCDBCalled) Bool_t AliITSPlaneEffSPD::ReadFromCDB() { // read from CDB if(!fInitCDBCalled) - {Error("AliITSPlaneEffSPD::ReadFromCDB","CDB not inizialized: call InitCDB first"); + {AliError("ReadFromCDB: CDB not inizialized. Call InitCDB first"); return kFALSE;} //if(!AliCDBManager::Instance()->IsDefaultStorageSet()) { // AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT"); @@ -359,3 +358,60 @@ if(this==eff) return kFALSE; eff->Copy(*this); return kTRUE; } +//_____________________________________________________________________________ +UInt_t AliITSPlaneEffSPD::GetKeyFromDetLocCoord(Int_t ilay, Int_t idet, + Float_t, Float_t locz) const { +// method to locate a basic block from Detector Local coordinate (to be used in tracking) +UInt_t key=999999; +if(ilay<0 || ilay>1) + {AliError("GetKeyFromDetLocCoord: you asked for a non existing layer"); + return key;} +if(ilay==0 && (idet<0 || idet>79)) + {AliError("GetKeyFromDetLocCoord: you asked for a non existing detector"); + return key;} +if(ilay==1 && (idet<0 || idet>159)) + {AliError("GetKeyFromDetLocCoord: you asked for a non existing detector"); + return key;} + +UInt_t mod=idet; +if(ilay==1) mod+=80; +key=GetKey(mod,GetChipFromCol(GetColFromLocZ(locz))); +return key; +} +//_____________________________________________________________________________ +UInt_t AliITSPlaneEffSPD::GetColFromLocZ(Float_t zloc) const { +UInt_t col=0; +/* note: as it is now, the AliITSsegmentationSPD::Init() does not properly initialize (6 chips !!!) +AliITSsegmentationSPD spd; +spd.Init(); +Int_t ix,iz; +if(spd.LocalToDet(0,zloc,ix,iz)) col+=iz; +else { + AliError("GetColFromLocZ: cannot compute column number from local z"); + col=99999;} +return col; +*/ +const Float_t kconv = 1.0E-04; // converts microns to cm. +Float_t bz[160]; +for(Int_t i=000;i<160;i++) bz[i] = 425.0; // most are 425 microns except below +bz[ 31] = bz[ 32] = 625.0; // first chip boundry +bz[ 63] = bz[ 64] = 625.0; // first chip boundry +bz[ 95] = bz[ 96] = 625.0; // first chip boundry +bz[127] = bz[128] = 625.0; // first chip boundry +// +Int_t j=-1; +Float_t dz=0; +for(Int_t i=000;i<160;i++) dz+=bz[i]; +dz = -0.5*kconv*dz; +if(zloc-1*dz) { // outside z range + AliDebug(1,Form("GetColFromLocZ: cannot compute column number from local z=%f",zloc)); + return 99999;} +for(j=0;j<160;j++){ + dz += kconv*bz[j]; + if(zloc #include "AliITSPlaneEffSSD.h" @@ -37,7 +37,6 @@ ClassImp(AliITSPlaneEffSSD) //______________________________________________________________________ AliITSPlaneEffSSD::AliITSPlaneEffSSD(): AliITSPlaneEff(){ - // Default constructor for (UInt_t i=0; i=kNModule) - {Error("AliITSPlaneEffSSD","you asked for a non existing module"); + {AliError("GetMissingTracksForGivenEff: you asked for a non existing module"); return -1;} else return GetNTracksForGivenEff(eff,RelErr)-fTried[GetKey(im)]; } @@ -147,7 +144,7 @@ Double_t AliITSPlaneEffSSD::PlaneEff(const UInt_t im) const { // Inputs: // im -> module number [0,1697] if (im>=kNModule) - {Error("AliITSPlaneEffSSD","you asked for a non existing module"); return -1.;} + {AliError("PlaneEff(UInt_t): you asked for a non existing module"); return -1.;} Int_t nf=fFound[GetKey(im)]; Int_t nt=fTried[GetKey(im)]; return AliITSPlaneEff::PlaneEff(nf,nt); @@ -159,7 +156,7 @@ Double_t AliITSPlaneEffSSD::ErrPlaneEff(const UInt_t im) const { // Inputs: // im -> module number [0,1697] if (im>=kNModule) - {Error("AliITSPlaneEffSSD","you asked for a non existing module"); return -1.;} + {AliError("ErrPlaneEff(UInt_t): you asked for a non existing module"); return -1.;} Int_t nf=fFound[GetKey(im)]; Int_t nt=fTried[GetKey(im)]; return AliITSPlaneEff::ErrPlaneEff(nf,nt); @@ -168,7 +165,7 @@ return AliITSPlaneEff::ErrPlaneEff(nf,nt); Bool_t AliITSPlaneEffSSD::UpDatePlaneEff(const Bool_t Kfound, const UInt_t im) { // Update efficiency for a basic block if (im>=kNModule) - {Error("AliITSPlaneEffSSD","you asked for a non existing module"); return kFALSE;} + {AliError("UpDatePlaneEff: you asked for a non existing module"); return kFALSE;} fTried[GetKey(im)]++; if(Kfound) fFound[GetKey(im)]++; return kTRUE; @@ -177,21 +174,21 @@ if (im>=kNModule) UInt_t AliITSPlaneEffSSD::GetKey(const UInt_t mod) const { // get key given a basic block if(mod>=kNModule) - {Error("AliITSPlaneEffSSD::GetKey","you asked for a non existing block"); return 99999;} + {AliError("GetKey: you asked for a non existing block"); return 99999;} return mod; } //__________________________________________________________________________ UInt_t AliITSPlaneEffSSD::GetModFromKey(const UInt_t key) const { // get mod. from key if(key>=kNModule) - {Error("AliITSPlaneEffSSD::GetModFromKey","you asked for a non existing key"); return 9999;} + {AliError("GetModFromKey: you asked for a non existing key"); return 9999;} return key; } //__________________________________________________________________________ Double_t AliITSPlaneEffSSD::LivePlaneEff(UInt_t key) const { // returns plane efficieny after adding the fraction of sensor which is bad if(key>=kNModule) - {Error("AliITSPlaneEffSSD::LivePlaneEff","you asked for a non existing key"); + {AliError("LivePlaneEff: you asked for a non existing key"); return -1.;} Double_t leff=AliITSPlaneEff::LivePlaneEff(0); // this just for the Warning leff=PlaneEff(key)+GetFracBad(key); @@ -201,7 +198,7 @@ return leff>1?1:leff; Double_t AliITSPlaneEffSSD::ErrLivePlaneEff(UInt_t key) const { // returns error on live plane efficiency if(key>=kNModule) - {Error("AliITSPlaneEffSSD::ErrLivePlaneEff","you asked for a non existing key"); + {AliError("ErrLivePlaneEff: you asked for a non existing key"); return -1.;} Int_t nf=fFound[key]; Double_t triedInLive=GetFracLive(key)*fTried[key]; @@ -212,7 +209,7 @@ return AliITSPlaneEff::ErrPlaneEff(nf,nt); // for the time being: to be checked Double_t AliITSPlaneEffSSD::GetFracLive(const UInt_t key) const { // returns the fraction of the sensor which is OK if(key>=kNModule) - {Error("AliITSPlaneEffSSD::GetFracLive","you asked for a non existing key"); + {AliError("GetFracLive: you asked for a non existing key"); return -1.;} // Compute the fraction of bad (dead+noisy) detector UInt_t bad=0; @@ -226,12 +223,12 @@ void AliITSPlaneEffSSD::GetBadInModule(const UInt_t key, UInt_t& nrBadInMod) con // returns the number of dead and noisy pixels nrBadInMod=0; if(key>=kNModule) - {Error("AliITSPlaneEffSSD::GetDeadAndNoisyInModule","you asked for a non existing key"); + {AliError("GetBadInModule: you asked for a non existing key"); return;} // Compute the number of bad (dead+noisy) pixel in a module // if(!fInitCDBCalled) - {Error("AliITSPlaneEffSSD::GetDeadAndNoisyInModule","CDB not inizialized: call InitCDB first"); + {AliError("GetBadInModule: CDB not inizialized: call InitCDB first"); return;}; AliCDBManager* man = AliCDBManager::Instance(); // retrieve map of dead Pixel @@ -240,10 +237,10 @@ TObjArray* ssdEntry; if(cdbSSD) { ssdEntry = (TObjArray*)cdbSSD->GetObject(); if(!ssdEntry) - {Error("AliITSPlaneEffSSD::GetDeadAndNoisyInChip"," SSDEntry not found in CDB"); + {AliError("GetBadInChip: SSDEntry not found in CDB"); return;} } else { - Error("AliITSPlaneEffSSD::GetDeadAndNoisyInChip","Did not find Calib/BadChannelsSSD"); + AliError("GetBadInChip: did not find Calib/BadChannelsSSD"); return; } // @@ -260,7 +257,7 @@ return; Double_t AliITSPlaneEffSSD::GetFracBad(const UInt_t key) const { // returns 1-fractional live if(key>=kNModule) - {Error("AliITSPlaneEffSSD::GetFracBad","you asked for a non existing key"); + {AliError("GetFracBad: you asked for a non existing key"); return -1.;} return 1.-GetFracLive(key); } @@ -268,7 +265,7 @@ return 1.-GetFracLive(key); Bool_t AliITSPlaneEffSSD::WriteIntoCDB() const { // write onto CDB if(!fInitCDBCalled) - {Error("AliITSPlaneEffSSD::WriteIntoCDB","CDB not inizialized: call InitCDB first"); + {AliError("WriteIntoCDB: CDB not inizialized. Call InitCDB first"); return kFALSE;} // to be written properly: now only for debugging AliCDBMetaData *md= new AliCDBMetaData(); // metaData describing the object @@ -287,7 +284,7 @@ if(!fInitCDBCalled) Bool_t AliITSPlaneEffSSD::ReadFromCDB() { // read from CDB if(!fInitCDBCalled) - {Error("AliITSPlaneEffSSD::ReadFromCDB","CDB not inizialized: call InitCDB first"); + {AliError("ReadFromCDB: CDB not inizialized. Call InitCDB first"); return kFALSE;} //if(!AliCDBManager::Instance()->IsDefaultStorageSet()) { // AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT"); @@ -298,3 +295,23 @@ if(this==eff) return kFALSE; eff->Copy(*this); return kTRUE; } +//_____________________________________________________________________________ +UInt_t AliITSPlaneEffSSD::GetKeyFromDetLocCoord(Int_t ilay, Int_t idet, + Float_t, Float_t) const { +// method to locate a basic block from Detector Local coordinate (to be used in tracking) +UInt_t key=999999; +if(ilay<4 || ilay>5) + {AliError("GetKeyFromDetLocCoord: you asked for a non existing layer"); + return key;} +if(ilay==4 && (idet<0 || idet>747)) + {AliError("GetKeyFromDetLocCoord: you asked for a non existing detector"); + return key;} +if(ilay==5 && (idet<0 || idet>949)) + {AliError("GetKeyFromDetLocCoord: you asked for a non existing detector"); + return key;} + +UInt_t mod=idet; +if(ilay==1) mod+=748; +key=GetKey(mod); +return key; +} diff --git a/ITS/AliITSPlaneEffSSD.h b/ITS/AliITSPlaneEffSSD.h index 4eba70b425e..91a97afe0d3 100644 --- a/ITS/AliITSPlaneEffSSD.h +++ b/ITS/AliITSPlaneEffSSD.h @@ -50,6 +50,11 @@ class AliITSPlaneEffSSD : public AliITSPlaneEff { virtual Bool_t ReadFromCDB(); // this method reads Data Members (statistics) from DataBase virtual Bool_t AddFromCDB() // this method updates Data Members (statistics) from DataBase {AliError("AddFromCDB: Still To be implemented"); return kFALSE;} + // method to locate a basic block from Detector Local coordinate (to be used in tracking) + // see file cxx for numbering convention. + // here idet runs from 0 to 747 for layer 4 and from 0 to 949 for layer 5 + UInt_t GetKeyFromDetLocCoord(Int_t ilay,Int_t idet, Float_t, Float_t locz) const; + UInt_t Nblock() const; // return the number of basic blocks protected: virtual void Copy(TObject &obj) const; @@ -66,5 +71,8 @@ class AliITSPlaneEffSSD : public AliITSPlaneEff { ClassDef(AliITSPlaneEffSSD,1) // SSD Plane Efficiency class }; +// +inline UInt_t AliITSPlaneEffSSD::Nblock() const {return kNModule;} +// #endif diff --git a/ITS/AliITStrackerMI.cxx b/ITS/AliITStrackerMI.cxx index 7756b16b118..15997d22599 100644 --- a/ITS/AliITStrackerMI.cxx +++ b/ITS/AliITStrackerMI.cxx @@ -43,12 +43,15 @@ #include "AliTrackPointArray.h" #include "AliAlignObj.h" #include "AliITSClusterParam.h" -#include "AliITSPlaneEff.h" #include "AliCDBManager.h" #include "AliCDBEntry.h" #include "AliITSCalibrationSPD.h" #include "AliITSCalibrationSDD.h" #include "AliITSCalibrationSSD.h" +#include "AliITSPlaneEff.h" +#include "AliITSPlaneEffSPD.h" +#include "AliITSPlaneEffSDD.h" +#include "AliITSPlaneEffSSD.h" #include "AliITStrackerMI.h" ClassImp(AliITStrackerMI) @@ -205,6 +208,19 @@ fPlaneEff(0) { fDebugStreamer = new TTreeSRedirector("ITSdebug.root"); + // only for plane efficiency evaluation + if (AliITSReconstructor::GetRecoParam()->GetComputePlaneEff()) { + for(Int_t ilay=0;ilay<6;ilay++) { + if(AliITSReconstructor::GetRecoParam()->GetLayersToSkip(ilay)) { + if (ilay<2) fPlaneEff = new AliITSPlaneEffSPD(); + else if (ilay<4) fPlaneEff = new AliITSPlaneEffSDD(); + else fPlaneEff = new AliITSPlaneEffSSD(); + break; // only one layer type to skip at once + } + } + if(!fPlaneEff->ReadFromCDB()) + {AliWarning("AliITStrackerMI reading of AliITSPlaneEff from OCDB failed") ;} + } } //------------------------------------------------------------------------ AliITStrackerMI::AliITStrackerMI(const AliITStrackerMI &tracker):AliTracker(tracker), @@ -632,7 +648,8 @@ Int_t AliITStrackerMI::RefitInward(AliESDEvent *event) { fTrackToFollow.ResetCovariance(10.); //Refitting... - if (RefitAt(AliITSRecoParam::GetrInsideSPD1(),&fTrackToFollow,t,kTRUE)) { + Bool_t pe=AliITSReconstructor::GetRecoParam()->GetComputePlaneEff(); + if (RefitAt(AliITSRecoParam::GetrInsideSPD1(),&fTrackToFollow,t,kTRUE,pe)) { fTrackToFollow.SetLabel(t->GetLabel()); // fTrackToFollow.CookdEdx(); CookdEdx(&fTrackToFollow); @@ -1890,13 +1907,15 @@ Int_t AliITStrackerMI::AliITSlayer::InRoad() const { } //------------------------------------------------------------------------ Bool_t AliITStrackerMI::RefitAt(Double_t xx,AliITStrackMI *track, - const AliITStrackMI *clusters,Bool_t extra) + const AliITStrackMI *clusters,Bool_t extra, Bool_t planeeff) { //-------------------------------------------------------------------- // This function refits the track "track" at the position "x" using // the clusters from "clusters" // If "extra"==kTRUE, // the clusters from overlapped modules get attached to "track" + // If "planeff"==kTRUE, + // special approach for plane efficiency evaluation is applyed //-------------------------------------------------------------------- Int_t index[AliITSgeomTGeo::kNLayers]; @@ -1909,17 +1928,19 @@ Bool_t AliITStrackerMI::RefitAt(Double_t xx,AliITStrackMI *track, index[ilayer]=idx; } - return RefitAt(xx,track,index,extra); // call the method below + return RefitAt(xx,track,index,extra,planeeff); // call the method below } //------------------------------------------------------------------------ Bool_t AliITStrackerMI::RefitAt(Double_t xx,AliITStrackMI *track, - const Int_t *clusters,Bool_t extra) + const Int_t *clusters,Bool_t extra, Bool_t planeeff) { //-------------------------------------------------------------------- // This function refits the track "track" at the position "x" using // the clusters from array // If "extra"==kTRUE, // the clusters from overlapped modules get attached to "track" + // If "planeff"==kTRUE, + // special approach for plane efficiency evaluation is applyed //-------------------------------------------------------------------- Int_t index[AliITSgeomTGeo::kNLayers]; Int_t k; @@ -2032,12 +2053,16 @@ Bool_t AliITStrackerMI::RefitAt(Double_t xx,AliITStrackMI *track, maxchi2=chi2; modstatus = 1; // found } else { - return kFALSE; + return kFALSE; // } } } else { // no cluster in this layer if (skip==1) { modstatus = 3; // skipped + if (planeeff) { // Plane Eff determination: + if (IsOKForPlaneEff(track,ilayer)) // only adequate track for plane eff. evaluation + UseTrackForPlaneEff(track,ilayer); + } } else { modstatus = 5; // no cls in road // check dead @@ -4901,3 +4926,133 @@ Bool_t AliITStrackerMI::LocalModuleCoord(Int_t ilayer,Int_t idet, return kTRUE; } //------------------------------------------------------------------------ +Bool_t AliITStrackerMI::IsOKForPlaneEff(AliITStrackMI* track, Int_t ilayer) const { +// Method still to be implemented: +// +// it will apply a pre-selection to obtain good quality tracks. +// Here also you will have the possibility to put a control on the +// impact point of the track on the basic block, in order to exclude border regions +// this will be done by calling a proper method of the AliITSPlaneEff class. +// +// input: AliITStrackMI* track, ilayer= layer number [0,5] +// output: Bool_t -> kTRUE if usable track, kFALSE if not usable. +return kTRUE; +} +//------------------------------------------------------------------------ +void AliITStrackerMI::UseTrackForPlaneEff(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. +// +// Method Purpose: estabilish whether a track has produced a recpoint or not +// in the layer under study (For Plane efficiency) +// +// inputs: AliITStrackMI* track (pointer to a usable track) +// outputs: none +// side effects: update (by 1 count) the Plane Efficiency statistics of the basic block +// traversed by this very track. In details: +// - if a cluster can be associated to the track then call +// AliITSPlaneEff::UpDatePlaneEff(key,kTRUE); +// - if not, the AliITSPlaneEff::UpDatePlaneEff(key,kFALSE) is called +// + AliITSlayer &layer=fgLayers[ilayer]; + Double_t r=layer.GetR(); + //AliITStrackV2 tmp(*track); + AliITStrackMI tmp(*track); + +// detector number + Double_t phi,z; + if (!tmp.GetPhiZat(r,phi,z)) return; + Int_t idet=layer.FindDetectorIndex(phi,z); + + if(idet<0) return; + + Double_t trackGlobXYZ1[3]; + tmp.GetXYZ(trackGlobXYZ1); + +// Get the budget to the primary vertex for the current track being prolonged + Double_t budgetToPrimVertex = GetEffectiveThickness(); + +//propagate to the intersection with the detector plane + const AliITSdetector &det=layer.GetDetector(idet); + if (!tmp.Propagate(det.GetPhi(),det.GetR())) return; + + //Float_t xloc,zloc; + +//*************** +// DEFINITION OF SEARCH ROAD FOR CLUSTERS SELECTION +// + Double_t dz=AliITSReconstructor::GetRecoParam()->GetNSigmaRoadZ()* + TMath::Sqrt(tmp.GetSigmaZ2() + + AliITSReconstructor::GetRecoParam()->GetNSigmaZLayerForRoadZ()* + AliITSReconstructor::GetRecoParam()->GetNSigmaZLayerForRoadZ()* + AliITSReconstructor::GetRecoParam()->GetSigmaZ2(ilayer)); + Double_t dy=AliITSReconstructor::GetRecoParam()->GetNSigmaRoadY()* + TMath::Sqrt(tmp.GetSigmaY2() + + AliITSReconstructor::GetRecoParam()->GetNSigmaYLayerForRoadY()* + AliITSReconstructor::GetRecoParam()->GetNSigmaYLayerForRoadY()* + AliITSReconstructor::GetRecoParam()->GetSigmaY2(ilayer)); + +// road in global (rphi,z) [i.e. in tracking ref. system] + Double_t zmin = tmp.GetZ() - dz; + Double_t zmax = tmp.GetZ() + dz; + Double_t ymin = tmp.GetY() + r*det.GetPhi() - dy; + Double_t ymax = tmp.GetY() + r*det.GetPhi() + dy; + +// select clusters in road + layer.SelectClusters(zmin,zmax,ymin,ymax); + +// Define criteria for track-cluster association + Double_t msz = tmp.GetSigmaZ2() + + AliITSReconstructor::GetRecoParam()->GetNSigmaZLayerForRoadZ()* + AliITSReconstructor::GetRecoParam()->GetNSigmaZLayerForRoadZ()* + AliITSReconstructor::GetRecoParam()->GetSigmaZ2(ilayer); + Double_t msy = tmp.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 +// + + const AliITSRecPoint *cl=0; Int_t clidx=-1, ci=-1; + Int_t idetc=-1; + Double_t maxchi2=1000.*AliITSReconstructor::GetRecoParam()->GetMaxChi2(), tolerance=0.1; + while ((cl=layer.GetNextCluster(clidx))!=0) { + idetc = cl->GetDetectorIndex(); + if(idet!=idetc) continue; + //Int_t ilay = cl->GetLayer(); + + if (TMath::Abs(tmp.GetZ() - cl->GetZ()) > tolerance) continue; + if (TMath::Abs(tmp.GetY() - cl->GetY()) > tolerance) continue; + + Double_t chi2=tmp.GetPredictedChi2(cl); + if (chi2GetKeyFromDetLocCoord(ilayer,idet,locx,locz); + if(key>fPlaneEff->Nblock()) return; + Bool_t found=kFALSE; + if (ci>=0) { + cl=layer.GetCluster(ci); + // here real control to see whether the cluster can be associated to the track. + // if() .... + found=kTRUE; + // track->SetExtraCluster(ilayer,(ilayer<<28)+ci); + // track->SetExtraModule(ilayer,idetExtra); + } + if(!fPlaneEff->UpDatePlaneEff(found,key)) + AliError(Form("UseTrackForPlaneEff: cannot UpDate PlaneEff for key=%d",key)); +return; +} diff --git a/ITS/AliITStrackerMI.h b/ITS/AliITStrackerMI.h index 33dbc3703f8..db9e904f4b3 100644 --- a/ITS/AliITStrackerMI.h +++ b/ITS/AliITStrackerMI.h @@ -19,6 +19,7 @@ class AliESDEvent; #include "AliITSRecPoint.h" #include "AliITStrackMI.h" #include "AliITSPlaneEff.h" +#include "AliPlaneEff.h" #include "AliTracker.h" //------------------------------------------------------------------------- @@ -41,9 +42,9 @@ public: Int_t PropagateBack(AliESDEvent *event); Int_t RefitInward(AliESDEvent *event); Bool_t RefitAt(Double_t x, AliITStrackMI *track, - const AliITStrackMI *clusters, Bool_t extra=kFALSE); + 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); + 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); @@ -54,6 +55,7 @@ public: void GetDCASigma(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 class AliITSdetector { public: AliITSdetector():fR(0),fPhi(0),fSinPhi(0),fCosPhi(0),fYmin(0),fYmax(0),fZmin(0),fZmax(0){} @@ -225,6 +227,11 @@ protected: Int_t CheckDeadZone(/*AliITStrackMI *track,*/Int_t ilayer,Int_t idet,Double_t zmin,Double_t zmax/*,Double_t ymin,Double_t ymax*/) const; Bool_t LocalModuleCoord(Int_t ilayer,Int_t idet,AliITStrackMI *track, Float_t &xloc,Float_t &zloc) const; +// method to be used for Plane Efficiency evaluation + Bool_t IsOKForPlaneEff(AliITStrackMI* track, 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 +// Int_t fI; // index of the current layer static AliITSlayer fgLayers[AliITSgeomTGeo::kNLayers];// ITS layers AliITStrackMI fTracks[AliITSgeomTGeo::kNLayers]; // track estimations at the ITS layers diff --git a/ITS/MakeITSPlaneEfficiencySDD.C b/ITS/MakeITSPlaneEfficiencySDD.C index a0053af12f0..60ab1b7ff9b 100644 --- a/ITS/MakeITSPlaneEfficiencySDD.C +++ b/ITS/MakeITSPlaneEfficiencySDD.C @@ -1,3 +1,12 @@ +#if !defined(__CINT__) || defined(__MAKECINT__) +#include +#include "AliCDBManager.h" +#include "AliCDBMetaData.h" +#include "AliCDBStorage.h" +#include "AliCDBRunRange.h" +#include "AliCDBId.h" +#include "AliITSPlaneEffSDD.h" +#endif void MakeITSPlaneEfficiencySDD(Int_t firstRun=0,Int_t lastRun=AliCDBRunRange::Infinity()){ if(!AliCDBManager::Instance()->IsDefaultStorageSet()) { @@ -8,11 +17,12 @@ void MakeITSPlaneEfficiencySDD(Int_t firstRun=0,Int_t lastRun=AliCDBRunRange::In md1->SetObjectClassName("AliITSPlaneEff"); md1->SetResponsible("Giuseppe Bruno"); md1->SetBeamPeriod(0); - md1->SetAliRootVersion("head 02/01/08"); //root version + md1->SetAliRootVersion("head 16/01/08"); //root version AliCDBId idplaneeffSDD("ITS/PlaneEff/PlaneEffSDD",firstRun, lastRun); AliITSPlaneEffSDD* planeeffSDD = new AliITSPlaneEffSDD(); + TRandom3 *gran = new TRandom3(); // planeeffSDD->SetOwner(kFALSE); @@ -27,10 +37,14 @@ void MakeITSPlaneEfficiencySDD(Int_t firstRun=0,Int_t lastRun=AliCDBRunRange::In // suppose to have 1000 tracks in each block and an average efficiency of 99% for(Int_t j=0; j<1000; j++) { BFound=kFALSE; - if (gRandom->Uniform(0,1000)>10) BFound=kTRUE; + //if (gRandom->Uniform(0,1000)>10) BFound=kTRUE; + if (1000*gran->Uniform()>10) BFound=kTRUE; planeeffSDD->UpDatePlaneEff(BFound,mod,chip,wing,subw); } }}}} if(AliCDBManager::Instance()->GetDefaultStorage()->Put(planeeffSDD, idplaneeffSDD, md1)) - {cout << "Riuscito " << endl;} + printf("Local CDB file with random SDD plane efficiencies written \n"); + delete gran; + delete planeeffSDD; + delete md1; } diff --git a/ITS/MakeITSPlaneEfficiencySPD.C b/ITS/MakeITSPlaneEfficiencySPD.C index 9508d097bf8..68d21cc4d01 100644 --- a/ITS/MakeITSPlaneEfficiencySPD.C +++ b/ITS/MakeITSPlaneEfficiencySPD.C @@ -1,5 +1,19 @@ -void MakeITSPlaneEfficiencySPD(Int_t firstRun=0,Int_t lastRun=AliCDBRunRange::Infinity()){ +#if !defined(__CINT__) || defined(__MAKECINT__) +#include +#include "AliCDBManager.h" +#include "AliCDBMetaData.h" +#include "AliCDBStorage.h" +#include "AliCDBRunRange.h" +#include "AliCDBId.h" +#include "AliITSPlaneEffSPD.h" +#endif + +void MakeITSPlaneEfficiencySPD(Int_t firstRun=0, Int_t lastRun=AliCDBRunRange::Infinity(), + Double_t eff=0.99, Int_t nTried=1000){ + if(eff<0 || eff > 1) { + printf("Efficiency must be in the range [0,1]: nothing done"); + } if(!AliCDBManager::Instance()->IsDefaultStorageSet()) { AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT"); } @@ -8,27 +22,37 @@ void MakeITSPlaneEfficiencySPD(Int_t firstRun=0,Int_t lastRun=AliCDBRunRange::In md1->SetObjectClassName("AliITSPlaneEff"); md1->SetResponsible("Giuseppe Bruno"); md1->SetBeamPeriod(0); - md1->SetAliRootVersion("head 19/11/07"); //root version + md1->SetAliRootVersion("head 16/02/08"); //root version AliCDBId idplaneeffSPD("ITS/PlaneEff/PlaneEffSPD",firstRun, lastRun); AliITSPlaneEffSPD* planeeffSPD = new AliITSPlaneEffSPD(); + TRandom3 *gran = new TRandom3(); // planeeffSPD->SetOwner(kFALSE); - +// Int_t nTried=1000; + Double_t limit=nTried; + limit*=(1-eff); + printf("limit = %f",limit); // loop over SPD chip Bool_t BFound=kFALSE; - //for(Int_t key=0;key<1200;key++){ - for(UInt_t mod=0;mod<240;mod++){ - for(UInt_t chip=0;chip<5;chip++){ + for(UInt_t key=0;keyNblock();key++){ + //for(UInt_t mod=0;mod<240;mod++){ + //for(UInt_t chip=0;chip<5;chip++){ // suppose to have 1000 tracks in each chip and an average efficiency of 99% - for(Int_t j=0; j<1000; j++) { + for(Int_t j=0; jUniform(0,1000)>10) BFound=kTRUE; - planeeffSPD->UpDatePlaneEff(BFound,mod,chip); + //if (gRandom->Uniform(0,1000)>10) BFound=kTRUE; + if (nTried*gran->Uniform()>limit) BFound=kTRUE; + //planeeffSPD->UpDatePlaneEff(BFound,mod,chip); + planeeffSPD->UpDatePlaneEff(BFound,key); } - }} + //}} + } if(AliCDBManager::Instance()->GetDefaultStorage()->Put(planeeffSPD, idplaneeffSPD, md1)) - {cout << "Riuscito " << endl;} -} \ No newline at end of file + printf("Local CDB file with random SPD plane efficiencies written \n"); + delete gran; + delete planeeffSPD; + delete md1; +} diff --git a/ITS/MakeITSPlaneEfficiencySSD.C b/ITS/MakeITSPlaneEfficiencySSD.C index a992aadb67f..6ec4f965688 100644 --- a/ITS/MakeITSPlaneEfficiencySSD.C +++ b/ITS/MakeITSPlaneEfficiencySSD.C @@ -1,3 +1,13 @@ +#if !defined(__CINT__) || defined(__MAKECINT__) +#include +#include "AliCDBManager.h" +#include "AliCDBMetaData.h" +#include "AliCDBStorage.h" +#include "AliCDBRunRange.h" +#include "AliCDBId.h" +#include "AliITSPlaneEffSSD.h" +#endif + void MakeITSPlaneEfficiencySSD(Int_t firstRun=0,Int_t lastRun=AliCDBRunRange::Infinity()){ if(!AliCDBManager::Instance()->IsDefaultStorageSet()) { @@ -13,6 +23,7 @@ void MakeITSPlaneEfficiencySSD(Int_t firstRun=0,Int_t lastRun=AliCDBRunRange::In AliCDBId idplaneeffSSD("ITS/PlaneEff/PlaneEffSSD",firstRun, lastRun); AliITSPlaneEffSSD* planeeffSSD = new AliITSPlaneEffSSD(); + TRandom3 *gran = new TRandom3(); // planeeffSSD->SetOwner(kFALSE); @@ -22,10 +33,14 @@ void MakeITSPlaneEfficiencySSD(Int_t firstRun=0,Int_t lastRun=AliCDBRunRange::In // suppose to have 1000 tracks in each module and an average efficiency of 99% for(Int_t j=0; j<1000; j++) { BFound=kFALSE; - if (gRandom->Uniform(0,1000)>10) BFound=kTRUE; + //if (gRandom->Uniform(0,1000)>10) BFound=kTRUE; + if (1000*gran->Uniform()>10) BFound=kTRUE; planeeffSSD->UpDatePlaneEff(BFound,mod); } } if(AliCDBManager::Instance()->GetDefaultStorage()->Put(planeeffSSD, idplaneeffSSD, md1)) - {cout << "Riuscito " << endl;} + printf("Local CDB file with random SSD plane efficiencies written \n"); + delete gran; + delete planeeffSSD; + delete md1; } diff --git a/ITS/PlaneEff/PlaneEffSDD/Run0_999999999_v0_s0.root b/ITS/PlaneEff/PlaneEffSDD/Run0_999999999_v0_s0.root index 67ca24464f541488da2a3f8c695344f3a6a0a587..193eee2c8c042fba443bce8ae7b8e4ba37fb08d5 100644 GIT binary patch literal 4720 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 B&yxTE delta 4131 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 Z_Wl1kV$lB)h-LnF0waFqaII&2{{z-751;@5 diff --git a/ITS/PlaneEff/PlaneEffSPD/Run0_999999999_v0_s0.root b/ITS/PlaneEff/PlaneEffSPD/Run0_999999999_v0_s0.root index e2ef344707ff8fd6d55f87b30dbc4a7826504c44..8171e984bc422f93c491edd7a159e1f631f3002c 100644 GIT binary patch delta 3406 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 delta 3326 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 HlllG${=sD$ diff --git a/ITS/PlaneEff/PlaneEffSSD/Run0_999999999_v0_s0.root b/ITS/PlaneEff/PlaneEffSSD/Run0_999999999_v0_s0.root index 7d5e6ac3068b531b5bbcb5283ae6e90d1c431800..c56973f3657187b4ec2d5eb31cd68a44aa76a5f7 100644 GIT binary patch delta 2391 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 +#include "AliPlaneEff.h" +#include "AliLog.h" +//#include "AliCDBManager.h" +//#include "AliCDBStorage.h" + +ClassImp(AliPlaneEff) +//______________________________________________________________________ +AliPlaneEff::AliPlaneEff(): TObject()/*, +fRunNumber(0), +fCDBUri(""), +fInitCDBCalled(kFALSE)*/ +{ + // Default constructor + // Inputs: + // none. + // Outputs: + // none. + // Return: + // a default constructed AliPlaneEff class + //InitCDB(); +} +//______________________________________________________________________ +AliPlaneEff::AliPlaneEff(const AliPlaneEff &s) : TObject(s)/*, +fRunNumber(s.fRunNumber), +fCDBUri(s.fCDBUri), +fInitCDBCalled(s.fInitCDBCalled)*/ +{ + // Copy Constructor + // Inputs: + // const AliPlaneEff &s simulation class to copy from + // Outputs: + // none. + // Return: + // a standard constructed AliPlaneEff class with values the same + // as that of s. + +} +//_________________________________________________________________________ +AliPlaneEff& AliPlaneEff::operator=(const AliPlaneEff &source){ + // Assignment operator + // Inputs: + // const AliPlaneEff &source simulation class to copy from + // Outputs: + // none. + // Return: + // a standard constructed AliPlaneEff class with values the same + // as that of s. + if(this != &source){ + source.Copy(*this); + } + return *this; +} +//_____________________________________________________________ +void AliPlaneEff::Copy(TObject &obj) const { + // copy this to obj +/* ((AliPlaneEff& ) obj).fRunNumber = fRunNumber; + ((AliPlaneEff& ) obj).fCDBUri = fCDBUri; + ((AliPlaneEff& ) obj).fInitCDBCalled = fInitCDBCalled; +*/ +} +//_________________________________________________________________________ diff --git a/STEER/AliPlaneEff.h b/STEER/AliPlaneEff.h new file mode 100644 index 00000000000..fe5187e6bb6 --- /dev/null +++ b/STEER/AliPlaneEff.h @@ -0,0 +1,54 @@ +#ifndef ALIPLANEEFF_H +#define ALIPLANEEFF_H +/* Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +#include +#include +#include "AliLog.h" + +//class Alisegmentation; +//class Aligeom; + +//////////////////////////////////////////////////// +// // +// Virtual base class for Plane Efficiency // +// Origin: Giuseppe.Bruno@ba.infn.it // +// // +//////////////////////////////////////////////////// + +class AliPlaneEff : public TObject { + public: + + AliPlaneEff();// Default constructor + virtual ~AliPlaneEff(){;}; + // copy constructor. See detector specific implementation. + AliPlaneEff(const AliPlaneEff &source); + // Assignment operator. See detector specific implementation. + AliPlaneEff& operator=(const AliPlaneEff &source); + // Average Plane efficiency (including dead/noisy) + //Int_t GetRunNumber() const {return fRunNumber;} + //void SetRunNumber(Int_t n) {fRunNumber=n;} + // + // Write into the data base + virtual Bool_t WriteIntoCDB() const + {AliError("This method must be implemented in a derived class"); return kFALSE;}; + virtual Bool_t ReadFromCDB() + {AliError("This method must be implemented in a derived class"); return kFALSE;}; + virtual Bool_t AddFromCDB() + {AliError("This method must be implemented in a derived class"); return kFALSE;}; + + protected: + + virtual void InitCDB(){;}; + virtual void Copy(TObject &obj) const; + //Int_t fRunNumber; //! run number (to access CDB) + //TString fCDBUri; //! Uri of the default CDB storage + //Bool_t fInitCDBCalled; //! flag to check if CDB storages are already initialized + + private: + //Int_t fRunNumber; // run number (to access CDB) + + ClassDef(AliPlaneEff,1) // Plane Efficiency virtual base class +}; +#endif diff --git a/STEER/AliReconstruction.cxx b/STEER/AliReconstruction.cxx index 77df274d975..8c98ad405f5 100644 --- a/STEER/AliReconstruction.cxx +++ b/STEER/AliReconstruction.cxx @@ -187,6 +187,8 @@ #include "AliQA.h" #include "AliQADataMakerSteer.h" +#include "AliPlaneEff.h" + #include "AliSysInfo.h" // memory snapshots @@ -251,7 +253,9 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename, fSetRunNumberFromDataCalled(kFALSE), fRunQA(kTRUE), fRunGlobalQA(kFALSE), - fInLoopQA(kFALSE) + fInLoopQA(kFALSE), + + fRunPlaneEff(kFALSE) { // create reconstruction object with default parameters @@ -320,7 +324,8 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) : fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled), fRunQA(rec.fRunQA), fRunGlobalQA(rec.fRunGlobalQA), - fInLoopQA(rec.fInLoopQA) + fInLoopQA(rec.fInLoopQA), + fRunPlaneEff(rec.fRunPlaneEff) { // copy constructor @@ -780,6 +785,10 @@ Bool_t AliReconstruction::Run(const char* input, Bool_t IsOnline) } } + //Initialize the Plane Efficiency framework + if (fRunPlaneEff && !InitPlaneEff()) { + if(fStopOnError) {CleanUp(file, fileOld); return kFALSE;} + } //******* The loop over events for (Int_t iEvent = 0; iEvent < fRunLoader->GetNumberOfEvents(); iEvent++) { @@ -1056,6 +1065,14 @@ Bool_t AliReconstruction::Run(const char* input, Bool_t IsOnline) esdFile->Close(); } +// Finish with Plane Efficiency evaluation + if (fRunPlaneEff && !FinishPlaneEff()) { + AliWarning("Finish PlaneEff evaluation failed"); + } + + gROOT->cd(); + CleanUp(file, fileOld); + // Create tags for the events in the ESD tree (the ESD tree is always present) // In case of empty events the tags will contain dummy values AliESDTagCreator *esdtagCreator = new AliESDTagCreator(); @@ -3046,3 +3063,42 @@ Int_t AliReconstruction::GetDetIndex(const char* detector) } return index ; } +//_____________________________________________________________________________ +Bool_t AliReconstruction::FinishPlaneEff() { + // + // Here execute all the necessary operationis, at the end of the tracking phase, + // in case that evaluation of PlaneEfficiencies was required for some detector. + // E.g., write into a DataBase file the PlaneEfficiency which have been evaluated. + // + // This Preliminary version works only FOR ITS !!!!! + // other detectors (TOF,TRD, etc. have to develop their specific codes) + // + // Input: none + // Return: kTRUE if all operations have been done properly, kFALSE otherwise + // + Bool_t ret=kFALSE; + //for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { + for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS + //if (!IsSelected(fgkDetectorName[iDet], detStr)) continue; + //if(fReconstructor[iDet]->GetRecoParam()->GetComputePlaneEff()) continue; + ret=fTracker[iDet]->GetPlaneEff()->WriteIntoCDB(); + } + return ret; +} +//_____________________________________________________________________________ +Bool_t AliReconstruction::InitPlaneEff() { +// + // Here execute all the necessary operations, before of the tracking phase, + // for the evaluation of PlaneEfficiencies, in case required for some detectors. + // E.g., read from a DataBase file a first evaluation of the PlaneEfficiency + // which should be updated/recalculated. + // + // This Preliminary version will work only FOR ITS !!!!! + // other detectors (TOF,TRD, etc. have to develop their specific codes) + // + // Input: none + // Return: kTRUE if all operations have been done properly, kFALSE otherwise + // + AliWarning(Form("Implementation of this method not yet done !! Method return kTRUE")); + return kTRUE; +} diff --git a/STEER/AliReconstruction.h b/STEER/AliReconstruction.h index 047eb24b898..aa6b015738b 100644 --- a/STEER/AliReconstruction.h +++ b/STEER/AliReconstruction.h @@ -119,6 +119,9 @@ public: void SetRunGlobalQA(Bool_t flag=kTRUE){fRunGlobalQA = flag;} void SetInLoopQA(Bool_t flag=kTRUE) {fInLoopQA = flag;} + // Plane Efficiency Evaluation + void SetRunPlaneEff(Bool_t flag=kFALSE) {fRunPlaneEff = flag;} + private: void InitCDB(); void SetCDBLock(); @@ -155,6 +158,10 @@ private: const Int_t GetQACycles(const char * detector) { return fQACycles[GetDetIndex(detector)] ; } void CheckQA() ; + // Plane Efficiency evaluation + Bool_t FinishPlaneEff(); //ultimate tasks related to Plane Eff. evaluation + Bool_t InitPlaneEff(); // initialize what is needed for Plane Eff. evaluation + //*** Global reconstruction flags ******************* Bool_t fUniformField; // uniform field tracking flag Bool_t fRunVertexFinder; // run the vertex finder @@ -219,6 +226,8 @@ private: Bool_t fRunQA ; // Run QA flag Bool_t fRunGlobalQA; // Run global QA flag Bool_t fInLoopQA; // In-loop QA flag + // Plane Efficiency Evaluation + Bool_t fRunPlaneEff ; // Evaluate Plane Efficiency ClassDef(AliReconstruction, 19) // class for running the reconstruction }; diff --git a/STEER/AliTracker.h b/STEER/AliTracker.h index 5c32f706e38..a8cfb738f15 100644 --- a/STEER/AliTracker.h +++ b/STEER/AliTracker.h @@ -11,6 +11,7 @@ // Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch //------------------------------------------------------------------------- #include +#include class TTree; class AliMagF; @@ -38,6 +39,7 @@ public: virtual Int_t LoadClusters(TTree *)=0; virtual void UnloadClusters()=0; virtual AliCluster *GetCluster(Int_t index) const=0; + virtual AliPlaneEff *GetPlaneEff() {return NULL;} virtual Bool_t GetTrackPoint(Int_t /* index */ , AliTrackPoint& /* p */) const { return kFALSE;} virtual Bool_t GetTrackPointTrackingError(Int_t /* index */, AliTrackPoint& /* p */, const AliESDtrack* /* t */) { return kFALSE;} diff --git a/STEER/STEERLinkDef.h b/STEER/STEERLinkDef.h index 3068c209c65..9ee73a3f2b3 100644 --- a/STEER/STEERLinkDef.h +++ b/STEER/STEERLinkDef.h @@ -128,6 +128,9 @@ #pragma link C++ class AliSurveyObj+; #pragma link C++ class AliSurveyPoint+; +#pragma link C++ class AliCodeTimer+; +#pragma link C++ class AliCodeTimer::AliPair+; + #pragma link C++ class AliFstream+; #pragma link C++ class AliCTPRawData+; @@ -142,5 +145,6 @@ #pragma link C++ class AliDetectorRecoParam+; #pragma link C++ class AliRecoParam+; +#pragma link C++ class AliPlaneEff+; #endif diff --git a/STEER/libSTEER.pkg b/STEER/libSTEER.pkg index 950d36fc2f0..a7c227dabea 100644 --- a/STEER/libSTEER.pkg +++ b/STEER/libSTEER.pkg @@ -45,6 +45,7 @@ AliHelix.cxx AliV0.cxx AliKink.cxx \ AliSelectorRL.cxx \ AliMagFMapsV1.cxx \ AliSurveyObj.cxx AliSurveyPoint.cxx \ +AliCodeTimer.cxx \ AliFstream.cxx \ AliCTPRawData.cxx \ AliQADataMaker.cxx \ @@ -56,8 +57,8 @@ AliQAChecker.cxx \ AliQACheckerBase.cxx \ AliMillepede.cxx \ AliRecoParam.cxx \ -AliDetectorRecoParam.cxx - +AliDetectorRecoParam.cxx \ +AliPlaneEff.cxx HDRS:= $(SRCS:.cxx=.h) -- 2.39.3