ITS/AliITS.h

   1 #ifndef ALIITS_H
   2 #define ALIITS_H
   3 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   4  * See cxx source for full Copyright notice                               */
   5
   6 /* $Id$ */
   7
   8 ////////////////////////////////////////////////////////////////////////
   9 //           Manager class for set: ITS                               //
  10 ////////////////////////////////////////////////////////////////////////
  11
  12 //#define NEWVERSION
  13
  14 #include <TObjArray.h> // used in inline function GetModule.
  15 #include <TBranch.h>   // used in inline function SetHitsAddressBranch
  16
  17 #include "AliRunLoader.h"
  18 #include "AliDetector.h"
  19 #ifndef NEWVERSION
  20 #include "AliITSDetType.h"
  21 #endif
  22 #ifdef NEWVERSION
  23 #include "AliITSDetTypeSim.h"
  24 #include "AliITSDetTypeRec.h"
  25 #endif
  26
  27 class TString;
  28 class TTree;
  29 class TFile;
  30
  31 class AliITSsimulation;
  32 class AliITSClusterFinder;
  33 class AliITSclusterV2;
  34 class AliITSLoader;
  35 class AliITSsegmentation;
  36 class AliITSresponse;
  37 class AliITShit;
  38 class AliITSgeom;
  39 class AliITSpListItem;
  40 class AliITSdigit;
  41 class AliITSRecPoint;
  42 class AliITSRawCluster;
  43 class AliITSmodule;
  44 class AliVertexer;
  45 class AliDigitizer;
  46 class AliRunDigitizer;
  47 class AliRawReader;
  48
  49 const Int_t kNTYPES=3;
  50
  51 class AliITS : public AliDetector {
  52
  53  public:
  54     //================= Standard Classes ===============================
  55     AliITS();  // Default creator.
  56     AliITS(const char *name, const char *title); // standard Creator
  57     virtual ~AliITS(); // destructor
  58     AliITS(const AliITS &source); // copy constructor. Not to be used!
  59     AliITS& operator=(AliITS &source); // = operator. Not to be used!
  60     virtual Int_t IsVersion() const {return 1;}
  61     virtual Int_t DistancetoPrimitive(Int_t,Int_t) const{return 999;};
  62
  63     //===================== Simulation Geometry ========================
  64     // get geometry version - detailed (major) or coarse (minor)
  65     virtual Int_t GetMajorVersion() const {return -1;}
  66     virtual Int_t GetMinorVersion() const {return -1;}
  67     virtual void  GetGeometryVersion(Int_t &a,Int_t &b)
  68                            {a = GetMajorVersion();b=GetMinorVersion();return;}
  69     virtual void  SetEUCLID(Bool_t euclid=kTRUE) {fEuclidOut = euclid;}
  70     virtual Bool_t GetEUCLID()const {return fEuclidOut;}
  71     //-------------------- Geometry Transformations --------------------
  72 #ifndef NEWVERSION
  73     // ITS geometry functions
  74     AliITSgeom   *GetITSgeom() const {return fITSgeom;}
  75     // Sets ITS geometry ! be very careful using this function.
  76     void   SetITSgeom(AliITSgeom *geom) {fITSgeom = geom;}
  77     // return pointer to the array of modules
  78     TObjArray    *GetModules() const {return fITSmodules;}
  79     // return pointer to a particular module
  80     AliITSmodule *GetModule(Int_t index) {return (AliITSmodule *)
  81                                               (fITSmodules->At(index));}
  82 #endif
  83 #ifdef NEWVERSION
  84     // ITS geometry functions
  85     AliITSgeom* GetITSgeom()const{if(fDetTypeSim!=0)
  86         return fDetTypeSim->GetITSgeom();else if(fDetTypeRec!=0)
  87             return fDetTypeRec->GetITSgeom();else return 0;}
  88     // ITS geometry functions From Simulation
  89     AliITSgeom* GetITSgeomSim()const{if(fDetTypeSim!=0)
  90         return fDetTypeSim->GetITSgeom();else return 0;}
  91     // ITS geometry functions From Reconstruction
  92     AliITSgeom* GetITSgeomRec()const{if(fDetTypeRec!=0)
  93         return fDetTypeRec->GetITSgeom();else return 0;}
  94     // Sets ITS geometry ! be very careful using this function.
  95     void   SetITSgeom(AliITSgeom *geom) {if(fDetTypeSim!=0)
  96         fDetTypeSim->SetITSgeom(geom);if(fDetTypeRec!=0)
  97             fDetTypeRec->SetITSgeom(geom);}
  98     // Sets ITS geometry For Simulation ! be very careful using this function.
  99     void   SetITSgeomSim(AliITSgeom *geom) {if(fDetTypeSim!=0)
 100         fDetTypeSim->SetITSgeom(geom);}
 101     // Sets ITS geometry For Reconstruction! be very careful using this fun.
 102     void   SetITSgeomRec(AliITSgeom *geom) {if(fDetTypeRec!=0)
 103         fDetTypeRec->SetITSgeom(geom);}
 104     // return pointer to the array of modules
 105     TObjArray    *GetModules() const {return fDetTypeSim->GetModules();}
 106     // return pointer to a particular module
 107     AliITSmodule *GetModule(Int_t index){return fDetTypeSim->GetModule(index);}
 108 #endif
 109
 110     //================ Necessary general Classes =======================
 111     virtual void Init();
 112     virtual AliLoader* MakeLoader(const char* topfoldername);
 113     virtual void SetDefaults();
 114     virtual void SetDefaultSimulation();
 115     virtual void SetDefaultClusterFinders();
 116     virtual void SetDefaultClusterFindersV2();
 117     virtual void MakeBranch(Option_t *opt=" ");
 118     virtual void SetTreeAddress();
 119 #ifndef NEWVERSION
 120     // For a given branch from the treeH sets the TClonesArray address.
 121     virtual void SetHitsAddressBranch(TBranch *b) {b->SetAddress(&fHits);}
 122     // Return pointer to DetType #id
 123     AliITSDetType *DetType(Int_t id){
 124         return ((AliITSDetType*) fDetTypes->At(id));};
 125     //Int_t           NDetTypes() {return fNDetTypes;}
 126 #endif
 127     //---------- Configuration Methods (per detector type) -------------
 128     // Determines which ITS subdetectors will be processed. Effects
 129     // digitization, and Reconstruction only.
 130     void SetDetectors(Option_t *opt="All"){fOpt = opt;}
 131     // Returns the list of ITS subdetectors that will be processed.
 132     Option_t* GetDetectors(){return fOpt;}
 133 #ifndef NEWVERSION
 134     // Set response
 135     virtual void SetResponseModel(Int_t id, AliITSresponse *response){
 136         ((AliITSDetType*) fDetTypes->At(id))->ResponseModel(response);};
 137     // Set segmentation
 138     virtual void SetSegmentationModel(Int_t id, AliITSsegmentation *seg){
 139         ((AliITSDetType*) fDetTypes->At(id))->SegmentationModel(seg);};
 140     // Set simulation - temporary
 141     virtual void SetSimulationModel(Int_t id, AliITSsimulation *sim){
 142         ((AliITSDetType*) fDetTypes->At(id))->SimulationModel(sim);};
 143     // Set simulation - temporary
 144     virtual AliITSsimulation* GetSimulationModel(Int_t id){
 145         return ((AliITSDetType*)(fDetTypes->At(id)))->GetSimulationModel();}
 146     // Set reconstruction
 147     virtual void SetReconstructionModel(Int_t id, AliITSClusterFinder *rec){
 148         ((AliITSDetType*) fDetTypes->At(id))->ReconstructionModel(rec);};
 149     // Set class names for digit and rec point
 150     virtual void SetClasses(Int_t id, const char *digit, const char *cluster){
 151         ((AliITSDetType*) fDetTypes->At(id))->ClassNames(digit,cluster);};
 152 #endif
 153 #ifdef NEWVERSION
 154     // Set response
 155     virtual void SetResponseModel(Int_t module, AliITSresponse *response){
 156         fDetTypeSim->SetResponseModel(module,response);};
 157     // Set segmentation for Simulation
 158     virtual void SetSegmentationModelSim(Int_t id, AliITSsegmentation *seg){
 159         fDetTypeSim->SetSegmentationModel(id,seg);};
 160     // Set segmentation for Reconstruction
 161     virtual void SetSegmentationModelRec(Int_t id, AliITSsegmentation *seg){
 162         fDetTypeRec->SetSegmentationModel(id,seg);};
 163     // Set segmentation
 164     virtual void SetSegmentationModel(Int_t id, AliITSsegmentation *seg){
 165         SetSegmentationModelSim(id,seg);SetSegmentationModelRec(id,seg);};
 166     // Set simulation
 167     virtual void SetSimulationModel(Int_t id, AliITSsimulation *sim){
 168         fDetTypesSim->SetSimulationModel(sim);};
 169     // Set simulation
 170     virtual AliITSsimulation* GetSimulationModel(Int_t id){
 171         return fDetTypesSim->GetSimulationModel(id);}
 172     // Set Calibration
 173     virtual void SetCalibrationModel(Int_t module, AliITSCalibration *cal){
 174         fDetTypeRec->SetCalibrationModel(module,cal);};
 175     // Set reconstruction
 176     virtual void SetReconstructionModel(Int_t id, AliITSClusterFinder *rec){
 177         fDetTypesRec->SetReconstructionModel(id,rec);};
 178     // Set Class name for Hits
 179     virtual void SetHitClassName(){
 180         fDetTypeSim->SetHitClassName(this->GetName());}
 181     // Set Class name for SDigits
 182     virtual void SetSDigitClassName(const char *sdigit){
 183         fDetTypeSim->SetSDigitClassName(sdigit);}
 184     // Set Class name for Digits for simulation
 185     virtual void SetDigitClassNameSim(const char *digit){
 186         fDetTypeSim->SetDigitClassName(digit);}///////// Array of names
 187     // Set Class name for Digits for Reconstruction
 188     virtual void SetDigitClassNameRec(const char *digit){
 189         fDetTypeRec->SetDigitClassName(digit);}///////// Array of names
 190     virtual void SetClusterClassName(const char *digit){
 191         fDetTypeRec->SetClusterClassName(digit);}///////// Array of names
 192     virtual void SetRecPointClassName(const char *digit){
 193         fDetTypeRec->SetRecPointClassName(digit);}///////// Array of names
 194     // Set class names for digit and rec point
 195     virtual void SetClasses(Int_t id, const char *digit, const char *cluster){
 196         SetDigitClassNameSim(digit);SetDigitClassNameRec(digit);
 197         SetRecPointClassName(cluster);};
 198 #endif
 199
 200     //=================== Hits =========================================
 201     virtual void StepManager() {} // See Step Manager for specific geometry.
 202     //------------ sort hits by module for Digitisation ----------------
 203     virtual void FillModules(Int_t evnt,Int_t bgrev,Int_t nmodules,
 204                              Option_t *opt, const char *filename);
 205 #ifndef NEWVERSION
 206     virtual void AddHit(Int_t track, Int_t *vol, Float_t *hits);
 207     virtual void InitModules(Int_t size,Int_t &nmodules);
 208     virtual void FillModules(TTree *treeH, Int_t mask = 0);
 209     virtual void ClearModules(){if(fITSmodules) fITSmodules->Delete();};
 210 #endif
 211 #ifdef NEWVERSION
 212     virtual void AddHit(Int_t track, Int_t *vol, Float_t *hits){
 213         if(fDetTypeSim!=0)fDetTypeSim->AddHit(track,vol,hits);};
 214     virtual void AddHit(AliITShit &hit){
 215         if(fDetTypeSim!=0)fDetTypeSim->AddHit(hit);};
 216     virtual void InitModules(Int_t size,Int_t &nmodules){if(fDetTypeSim!=0)
 217         fDetTypeSim->InitModules(size,nmodules);};
 218     virtual void FillModules(TTree *treeH, Int_t mask = 0){if(fDetTypeSim!=0)
 219         fDetTypeSim->FillModules(treeH,mask);};
 220     virtual void ClearModules(){if(fDetTypeSim!=0)
 221         fDetTypeSim->ClearModules();};
 222 #endif
 223
 224     //===================== Digitisation ===============================
 225 #ifndef NEWVERSION
 226     void MakeBranchS(const char *file);
 227     void SetTreeAddressS(TTree *treeS);
 228     TClonesArray * GetSDigits() { return fSDigits; }
 229     void MakeBranchInTreeD(TTree *treeD,const char *file=0);
 230     void MakeBranchD(const char *file){
 231         MakeBranchInTreeD(GetLoader()->TreeD(),file);}
 232     void SetTreeAddressD(TTree *treeD);
 233 #endif
 234 #ifndef NEWVERSION
 235     void Hits2SDigits(); // Turn hits into SDigits
 236     void Hits2PreDigits(){ // Turn hits into SDigits
 237         HitsToPreDigits(fLoader->GetRunLoader()->GetEventNumber(),
 238                         0,-1," ",fOpt," ");};
 239     AliDigitizer* CreateDigitizer(AliRunDigitizer* manager) const;
 240     void SDigits2Digits(){SDigitsToDigits("All");} // Turn SDigits to Digits
 241     void SDigitsToDigits(Option_t *opt="All"); // Turn SDigits to Digits
 242     void Hits2Digits(); // Turn hits straight into Digits.
 243     //------------------ Internal functions ----------------------------
 244     // Standard Hits To SDigits function
 245     void HitsToSDigits(Int_t evNumber,Int_t bgrev,Int_t size,
 246                        Option_t *add, Option_t *det, const char *filename)
 247         {HitsToPreDigits(evNumber,bgrev,size,add,det,filename);};
 248     // Standard Hits To SDigits function
 249     void HitsToPreDigits(Int_t evNumber,Int_t bgrev,Int_t size,
 250                  Option_t *add, Option_t *det, const char *filename);
 251     // Standard Hits To Digits function
 252     void HitsToDigits(Int_t evNumber,Int_t bgrev,Int_t size,
 253                  Option_t *add, Option_t *det, const char *filename);
 254 #endif
 255 #ifdef NEWVERSION
 256     // Turn hits into SDigits
 257     void Hits2SDigits(){if(fDetTypeSim)fDetTypeSim->Hits2SDigits();};
 258     AliDigitizer* CreateDigitizer(AliRunDigitizer* manager) const;
 259     // Turn SDigits to Digits
 260     void SDigits2Digits(){if(fDetTypeSim)fDetTypeSim->SDigits2Digits();}
 261     // Turn hits straight into Digits.
 262     void Hits2Digits(){if(fDetTypeSim)fDetTypeSim->Hits2Digits();};
 263 #endif
 264     // Resets the Summable digits.
 265 #ifndef NEWVERSION
 266     void ResetSDigits(){if(fSDigits) fSDigits->Clear();fNSDigits = 0;};
 267     void ResetDigits();                   // depending on how the
 268     void ResetDigits(Int_t branch);       // tree will be filled only
 269     void AddSumDigit(AliITSpListItem &sdig);
 270     void AddRealDigit(Int_t branch, Int_t *digits);
 271     void AddSimDigit(Int_t branch, AliITSdigit *d);
 272     void AddSimDigit(Int_t branch,Float_t phys,Int_t* digits,
 273                      Int_t* tracks,Int_t *hits,Float_t* trkcharges);
 274 #endif
 275     // Return pointers to digits
 276 #ifndef NEWVERSION
 277     TObjArray    *Dtype() {return fDtype;}
 278     Int_t        *Ndtype() {return fNdtype;}
 279     TClonesArray *DigitsAddress(Int_t id)
 280         {return ((TClonesArray *) (*fDtype)[id]);}
 281 #endif
 282 #ifdef NEWVERSION
 283     TObjArray* GetDigitsSim(){if(fDetTypeSim!=0)
 284         return fDetTypeSim->GetDigits();else return 0;}
 285     TObjArray* GetDigitsRec(){if(fDetTypeRec!=0)
 286         return fDetTypeRec->GetDigits();else return 0;}
 287     TObjArray    *Dtype() {if(fDetTypeSim!=0) return GetDigitsSim();
 288     else if(fDetTypeRec!=0) return GetDigitsRec(); else return 0;}
 289     Int_t* GetNDigitArraySim(){if(fDetTypeSim!=0)
 290         fDetTypeSim->GetNDigitArray();}
 291     Int_t* GetNDigitArrayRec(){if(fDetTypeRec!=0)
 292         fDetTypeRec->GetNDigitArray();}
 293     Int_t        *Ndtype() {if(fDetTypeSim!=0) return GetNDigitArraySim();
 294         else if(fDetTypeRec!=0) return GetNDigitArrayRec(); else return 0;}
 295     TClonesArray *DigitsAddressSim(Int_t id){if(fDetTypeSim!=0)
 296         return fDetTypeSim->GetDigitsAddress(id);else return 0;}
 297     TClonesArray *DigitsAddressRec(Int_t id){if(fDetTypeRec!=0)
 298         return fDetTypeRec->GetDigitsAddress(id);else return 0;}
 299     TClonesArray *DigitsAddress(Int_t id){if(fDetTypeSim!=0)
 300         return DigitsAddressSim(id);else if(fDetTypeRec!=0) DigitsAddressRec(id);
 301      else return 0;}
 302 #endif
 303     void SelectVertexer(TString sel=" "){fSelectedVertexer = sel;}
 304 #ifndef NEWVERSION
 305
 306     //===================== Raw Data IO ================================
 307     // Write digits into raw data format
 308     virtual void Digits2Raw();
 309
 310     //==================== Clusterization ==============================
 311     // create separate tree for clusters - declustering refining
 312     void MakeTreeC(Option_t *option="C");
 313     void GetTreeC(Int_t event);
 314     void AddCluster(Int_t branch, AliITSRawCluster *c);
 315     // one of the methods in
 316     void ResetClusters(){for(Int_t i=0;i<kNTYPES;i++ ) ResetClusters(i);};
 317     void ResetClusters(Int_t branch);     // the pair will be kept
 318     void MakeBranchC();
 319     // Return pointers to clusters
 320     TObjArray    *Ctype() {return fCtype;}
 321     Int_t        *Nctype() {return fNctype;}
 322     TClonesArray *ClustersAddress(Int_t id)
 323                    {return ((TClonesArray *) (*fCtype)[id]);}
 324 #endif
 325 #ifdef NEWVERSION
 326
 327     //===================== Raw Data IO ================================
 328     // Write digits into raw data format
 329     virtual void Digits2Raw(){if(fDetTypeSim)fDetTypeSim->Digits2Raw();};
 330
 331     //==================== Clusterization ==============================
 332     // create separate tree for clusters - declustering refining
 333     void MakeTreeC(Option_t *option="C"){fDetTypeRec->MakeTreeC();};
 334     void GetTreeC(Int_t event){fDetTypeRec->GetTreeC(event);};
 335     void AddCluster(Int_t branch, AliITSRawCluster *c){
 336         fDetTypeRec->AddCluster(branch,c);};
 337     // one of the methods in
 338     void ResetClusters(){for(Int_t i=0;i<kNTYPES;i++ ) ResetClusters(i);};
 339     void ResetClusters(Int_t branch){fDetTypeRec->ResetCluster(i);};
 340     void MakeBranchC(){fDetTypeRec->MakeBranchC();};
 341     // Return pointers to clusters
 342     TObjArray    *Ctype() {if(fDetTypeRec!=0)
 343         return fDetTypeRec->GetClusterArray(); else return 0;}
 344     Int_t        *Nctype() {if(fDetTypeRec!=0)
 345         return fDetTypeRec->GetNClusters(); else return 0;;}
 346     TClonesArray *ClustersAddress(Int_t id){if(fDetTypeRec!=0)
 347         return fDetTypeRec->GetClusterAddress(id]); else return 0;}
 348 #endif
 349
 350     //=================== Reconstruction ===============================
 351 #ifndef NEWVERSION
 352     void MakeBranchR(const char *file, Option_t *opt=" ");
 353     void SetTreeAddressR(TTree *treeR);
 354     void AddRecPoint(const AliITSRecPoint &p);
 355     void ResetRecPoints(){if(fRecPoints) fRecPoints->Clear();fNRecPoints = 0;};
 356     // Return pointer to rec points
 357     TClonesArray  *RecPoints()   {return fRecPoints;}
 358
 359     void AddClusterV2(const AliITSclusterV2 &cl);
 360     void ResetClustersV2(){if(fClustersV2) fClustersV2->Clear();fNClustersV2=0;}
 361     Int_t GetNClustersV2()const {return fNClustersV2;}
 362 // Return pointer to clustersV2
 363 TClonesArray *ClustersV2() {return fClustersV2;}
 364 #endif
 365 #ifdef NEWVERSION
 366     void MakeBranchR(const char *file, Option_t *opt=" ");
 367     void SetTreeAddressR(TTree *treeR){fDetTypeRec->SetTreeAddressR(treeR);};
 368     void AddRecPoint(const AliITSRecPoint &p){fDetTypeRec->AddRecPoint(p);};
 369     void ResetRecPoints(){if(fDetTypeRec) fDetTypeRec->ResetRecPoints();};
 370     // Return pointer to rec points
 371     TClonesArray* RecPoints() {if(fDetTypeRec!=0)
 372         return fDetTypeRec->GetRecPoints();else return 0;}
 373 #endif
 374     void MakeBranchRF(const char *file){MakeBranchR(file,"Fast");}
 375     void HitsToFastRecPoints(Int_t evNumber,Int_t bgrev,Int_t size,
 376                  Option_t *add, Option_t *det, const char *filename);
 377     void Digits2Reco(){
 378         DigitsToRecPoints(fLoader->GetRunLoader()->GetEventNumber(),0,fOpt);};
 379     void DigitsToRecPoints(Int_t evNumber,Int_t lastEntry,Option_t *det);
 380 void DigitsToRecPoints(AliRawReader* rawReader);
 381  protected:
 382     //================== Data Members ==================================
 383 #ifdef NEWVERSION
 384     AliITSDetTypeSim *fDetTypeSim; //
 385     AliITSDetTypeRec *fDetTypeRec; //
 386 #endif
 387 #ifndef NEWVERSION
 388     AliITSgeom   *fITSgeom;    // Pointer to ITS geometry
 389 #endif
 390     Bool_t        fEuclidOut;  // Flag to write geometry in euclid format
 391 #ifndef NEWVERSION
 392     TObjArray    *fITSmodules; //! Pointer to ITS modules
 393 #endif
 394     Option_t     *fOpt;        //! Detector option ="All" unless changed.
 395
 396     Int_t         fIdN;        // the number of layers
 397     Int_t        *fIdSens;     //[fIdN] layer identifier
 398     TString      *fIdName;     //[fIdN] layer identifier
 399 #ifndef NEWVERSION
 400     Int_t         fNDetTypes;  // Number of detector types
 401     TObjArray    *fDetTypes;   // List of detector types
 402
 403     TClonesArray  *fSDigits;    //! List of Summable digits.
 404     Int_t         fNSDigits;   // Number of Summable Digits.
 405
 406     TObjArray    *fDtype;      //! List of digits
 407     Int_t        *fNdtype;     //[fNDetTypes] Num. of digits per type of det.
 408
 409     TObjArray    *fCtype;      //! List of clusters
 410     Int_t        *fNctype;     //[fNDetTypes] Num. of clust. per type of det.
 411
 412     TClonesArray *fRecPoints;  //! List of reconstructed points
 413     Int_t         fNRecPoints; // Number of rec points
 414
 415     TClonesArray *fClustersV2; //!List of reconstructed clusters v2
 416     Int_t         fNClustersV2;    //Number of clusters v2
 417
 418 #endif
 419     TString fSelectedVertexer; // Vertexer selected in CreateVertexer
 420 #ifndef NEWVERSION
 421     ClassDef(AliITS,5) // Base class for ITS
 422 #endif
 423 #ifdef NEWVERSION
 424     ClassDef(AliITS,5) // Base class for ITS
 425 #endif
 426 };
 427
 428 #endif