Removed obsolete scripts

[u/mrichter/AliRoot.git] / ITS / UPGRADE / DetectorK.h

#ifndef DETECTORK_H\r
#define DETECTORK_H\r
\r
#include <TNamed.h>\r
#include <TList.h>\r
#include <TGraph.h>\r
#include <Riostream.h>\r
\r
/***********************************************************\r
\r
Fast Simulation tool for Inner Tracker Systems\r
\r
original code of using the billoir technique was developed\r
for the HFT (STAR), James H. Thomas, jhthomas@lbl.gov\r
http://rnc.lbl.gov/~jhthomas\r
\r
Changes by S. Rossegger\r
\r
July 2011  - Adding the possibility of "fake calculation" and "efficiency calculation" \r
             with a number of "at least correct clusters on the track"\r
             Done using the complete combinatorics table with 3^nLayer track outcomes.\r
\r
April 2011 - Now uses the Kalman method (aliroot implementation) instead of the Billoir\r
             technique ... (changes by Ruben Shahoyan)\r
\r
March 2011 - Changes to comply with the Alice Offline coding conventions\r
\r
Feb. 2011 - Improvement in "lowest pt allowed" -> now uses helix param. for calc. of a,b\r
\r
          - Adding a more sophisticaed efficiency calculation which includes\r
            the possibility to make chi2 cuts via Confidence Levels (method of Ruben Shahoyan)\r
            plus adding 'basic' detection efficiencies per layer ...\r
\r
          - Adding "ITS Stand alone" tracking capabilities via \r
            forward+backward tracking -> Kalman smoothing is then \r
            used for the parameter estimates (important for efficiencies)\r
\r
Jan. 2011 - Inclusion of ImpactParameter Plots (with vtx estimates)\r
            to allow comparison with ITS performances in pp data\r
\r
Dec. 2010 - Translation into C++ class format \r
          - Adding various Setters and Getters to build the geometry \r
	    (based on cylinders) plus handling of the layer properties \r
\r
\r
***********************************************************/\r
\r
class AliExternalTrackParam; \r
#include <TMatrixD.h>\r
\r
class DetectorK : public TNamed {\r
\r
 public:\r
  \r
  DetectorK();\r
  DetectorK(char *name,char *title);\r
  virtual ~DetectorK();\r
\r
  enum {kNptBins = 100}; // less then 400 !!\r
 \r
  void AddLayer(char *name, Float_t radius, Float_t radL, Float_t phiRes=999999, Float_t zRes=999999, Float_t eff=0.99);\r
\r
  void KillLayer(char *name);\r
  void SetRadius(char *name, Float_t radius);\r
  void SetRadiationLength(char *name, Float_t radL);\r
  void SetResolution(char *name, Float_t phiRes=999999, Float_t zRes=999999);\r
  void SetLayerEfficiency(char *name, Float_t eff=1.0);\r
  void RemoveLayer(char *name);\r
\r
  Float_t GetRadius(char *name);\r
  Float_t GetRadiationLength(char *name);\r
  Float_t GetResolution(char *name, Int_t axis=0);\r
  Float_t GetLayerEfficiency(char *name);\r
\r
  void PrintLayout(); \r
  void PlotLayout(Int_t plotDead = kTRUE);\r
  \r
  void MakeAliceAllNew(Bool_t flagTPC =1,Bool_t flagMon=1);\r
  void MakeAliceCurrent(Int_t AlignResiduals = 0, Bool_t flagTPC =1);\r
  void AddTPC(Float_t phiResMean, Float_t zResMean, Int_t skip=1);\r
  void RemoveTPC();\r
\r
  void SetBField(Float_t bfield) {fBField = bfield; }\r
  Float_t GetBField() const {return fBField; }\r
  void SetLhcUPCscale(Float_t lhcUPCscale) {fLhcUPCscale = lhcUPCscale; }\r
  Float_t GetLhcUPCscale() const { return fLhcUPCscale; }\r
  void SetParticleMass(Float_t particleMass) {fParticleMass = particleMass; }\r
  Float_t GetParticleMass() const { return fParticleMass; }\r
  void SetIntegrationTime(Float_t integrationTime) {fIntegrationTime = integrationTime; }\r
  Float_t GetIntegrationTime() const { return fIntegrationTime; }\r
  void SetMaxRadiusOfSlowDetectors(Float_t maxRadiusSlowDet) {fMaxRadiusSlowDet =  maxRadiusSlowDet; }\r
  Float_t GetMaxRadiusOfSlowDetectors() const { return fMaxRadiusSlowDet; }\r
  void SetAvgRapidity(Float_t avgRapidity) {fAvgRapidity = avgRapidity; }\r
  Float_t GetAvgRapidity() const { return fAvgRapidity; }\r
  void SetConfidenceLevel(Float_t confLevel) {fConfLevel = confLevel; }\r
  Float_t GetConfidenceLevel() const { return fConfLevel; }\r
  void SetAtLeastCorr(Int_t atLeastCorr ) {fAtLeastCorr = atLeastCorr; }\r
  Int_t GetAtLeastCorr() const { return fAtLeastCorr; }\r
  void SetAtLeastFake(Int_t atLeastFake ) {fAtLeastFake = atLeastFake; }\r
  Int_t GetAtLeastFake() const { return fAtLeastFake; }\r
\r
  void SetdNdEtaCent(Int_t dNdEtaCent ) {fdNdEtaCent = dNdEtaCent; }\r
  Float_t GetdNdEtaCent() const { return fdNdEtaCent; }\r
\r
  \r
  Float_t GetNumberOfActiveLayers() const {return fNumberOfActiveLayers; }\r
  Float_t GetNumberOfActiveITSLayers() const {return fNumberOfActiveITSLayers; }\r
\r
  void SolveViaBilloir(Int_t flagD0=1,Int_t print=1, Bool_t allPt=1, Double_t meanPt =0.750);\r
  void SolveDOFminusOneAverage();\r
\r
  // Helper functions\r
  Double_t ThetaMCS                 ( Double_t mass, Double_t RadLength, Double_t momentum ) const;\r
  Double_t ProbGoodHit              ( Double_t radius, Double_t searchRadiusRPhi, Double_t searchRadiusZ )   ; \r
  Double_t ProbGoodChiSqHit         ( Double_t radius, Double_t searchRadiusRPhi, Double_t searchRadiusZ )   ; \r
  Double_t ProbGoodChiSqPlusConfHit ( Double_t radius, Double_t leff, Double_t searchRadiusRPhi, Double_t searchRadiusZ )   ; \r
  Double_t ProbNullChiSqPlusConfHit ( Double_t radius, Double_t leff, Double_t searchRadiusRPhi, Double_t searchRadiusZ )   ; \r
 \r
  // Howard W. hit distribution and convolution integral\r
  Double_t Dist              ( Double_t Z, Double_t radius ) ;  \r
  Double_t HitDensity        ( Double_t radius )   ;\r
  Double_t UpcHitDensity     ( Double_t radius )   ;\r
  Double_t IntegratedHitDensity  ( Double_t multiplicity, Double_t radius )   ;\r
  Double_t OneEventHitDensity    ( Double_t multiplicity, Double_t radius ) const   ;\r
  Double_t D0IntegratedEfficiency( Double_t pt, Double_t corrEfficiency[][400] ) const ;\r
  \r
  TGraph* GetGraphMomentumResolution(Int_t color, Int_t linewidth=1);\r
  TGraph* GetGraphPointingResolution(Int_t axis,Int_t color, Int_t linewidth=1);\r
  TGraph* GetGraphPointingResolutionTeleEqu(Int_t axis,Int_t color, Int_t linewidth=1);\r
\r
  TGraph* GetGraphImpactParam(Int_t mode, Int_t axis, Int_t color, Int_t linewidth=1);\r
\r
  TGraph* GetGraphRecoEfficiency(Int_t particle, Int_t color, Int_t linewidth=1); \r
  TGraph* GetGraphRecoFakes(Int_t particle,Int_t color, Int_t linewidth);\r
  TGraph* GetGraphRecoPurity(Int_t particle,Int_t color, Int_t linewidth);\r
\r
  TGraph* GetGraph(Int_t number, Int_t color, Int_t linewidth=1);\r
\r
  void MakeStandardPlots(Bool_t add =0, Int_t color=1, Int_t linewidth=1,Bool_t onlyPionEff=0);\r
\r
  // method to extend AliExternalTrackParam functionality\r
  Bool_t GetXatLabR(AliExternalTrackParam* tr,Double_t r,Double_t &x, Double_t bz, Int_t dir=0) const;\r
\r
  Double_t* PrepareEffFakeKombinations(TMatrixD *probKomb, TMatrixD *probLay);\r
\r
 protected:\r
 \r
  Int_t fNumberOfLayers;        // total number of layers in the model\r
  Int_t fNumberOfActiveLayers;  // number of active layers in the model\r
  Int_t fNumberOfActiveITSLayers;  // number of active ITS layers in the model\r
  TList fLayers;                // List of layer pointers\r
  Float_t fBField;              // Magnetic Field in Tesla\r
  Float_t fLhcUPCscale;         // UltraPeripheralElectrons: scale from RHIC to LHC\r
  Float_t fIntegrationTime;     // electronics integration time\r
  Float_t fConfLevel;           // Confidence Level for the tracking\r
  Float_t fAvgRapidity;         // rapidity of the track (= mean)\r
  Float_t fParticleMass;        // Particle used for tracking. Standard: mass of pion\r
  Double_t fMaxRadiusSlowDet;   // Maximum radius for slow detectors.  Fast detectors \r
                                // and only fast detectors reside outside this radius.\r
  Int_t fAtLeastCorr;     // min. number of correct hits for the track to be "good"\r
  Int_t fAtLeastFake;     // min. number of fake hits for the track to be "fake"\r
\r
  Int_t fdNdEtaCent;       // Multiplicity\r
\r
  enum {kMaxNumberOfDetectors = 200};\r
 \r
  Double_t fTransMomenta[kNptBins];                          // array of transverse momenta\r
  Double_t fMomentumRes[kNptBins];                           // array of momentum resolution\r
  Double_t fResolutionRPhi[kNptBins];                        // array of rphi resolution\r
  Double_t fResolutionZ[kNptBins];                           // array of z resolution\r
  Double_t fDetPointRes[kMaxNumberOfDetectors][kNptBins];    // array of rphi resolution per layer\r
  Double_t fDetPointZRes[kMaxNumberOfDetectors][kNptBins];   // array of z resolution per layer\r
  Double_t fEfficiency[3][kNptBins];                         // efficiency for different particles\r
  Double_t fFake[3][kNptBins];                               // fake prob for different particles\r
\r
  ClassDef(DetectorK,1);\r
};\r
\r
#endif\r