ITS/AliITSLoader.cxx

   1 #include "AliITS.h"
   2 #include "AliITSgeom.h"
   3 #include "AliITSdigit.h"
   4 #include "AliRun.h"
   5 #include "AliDetector.h"
   6 #include "AliITSLoader.h"
   7
   8 ///////////////////////////////////////////////////////////////////////////
   9 // Loader for ITS
  10 // it manages the I/O for:
  11 // raw clusters, primary vertices
  12 // V0 and cascade
  13 // and tracks propagated to the origin
  14 //////////////////////////////////////////////////////////////////////////
  15 const TString AliITSLoader::fgkDefaultRawClustersContainerName = "TreeC";
  16 const TString AliITSLoader::fgkDefaultBackTracksContainerName = "TreeB";
  17 const TString AliITSLoader::fgkDefaultVerticesContainerName = "Vertex";
  18 const TString AliITSLoader::fgkDefaultV0ContainerName = "V0";
  19 const TString AliITSLoader::fgkDefaultCascadeContainerName = "Cascade";
  20
  21 ClassImp(AliITSLoader)
  22
  23 /**********************************************************************/
  24   AliITSLoader::AliITSLoader():AliLoader(){
  25   // Default constructor
  26 }
  27 /*********************************************************************/
  28 AliITSLoader::AliITSLoader(const Char_t *name,const Char_t *topfoldername):
  29 AliLoader(name,topfoldername){
  30   //ctor
  31     AliDataLoader* rawClustersDataLoader = new AliDataLoader(
  32         fDetectorName + ".RawCl.root",fgkDefaultRawClustersContainerName,
  33         "Raw Clusters");
  34     fDataLoaders->Add(rawClustersDataLoader);
  35     rawClustersDataLoader->SetEventFolder(fEventFolder);
  36     rawClustersDataLoader->SetFolder(GetDetectorDataFolder());
  37
  38     AliDataLoader* backTracksDataLoader =  new AliDataLoader(
  39         fDetectorName + ".BackTracks.root",fgkDefaultBackTracksContainerName,
  40         "Back Propagated Tracks");
  41     fDataLoaders->Add(backTracksDataLoader);
  42     backTracksDataLoader->SetEventFolder(fEventFolder);
  43     backTracksDataLoader->SetFolder(GetDetectorDataFolder());
  44
  45     AliDataLoader* vertexDataLoader = new AliDataLoader(
  46         fDetectorName + ".Vertex.root",fgkDefaultVerticesContainerName,
  47         "Primary Vertices","O");
  48     fDataLoaders->Add(vertexDataLoader);
  49     vertexDataLoader->SetEventFolder(fEventFolder);
  50     vertexDataLoader->SetFolder(GetDetectorDataFolder());
  51
  52     AliDataLoader* v0DataLoader = new AliDataLoader(
  53         fDetectorName + ".V0s.root",fgkDefaultV0ContainerName,"V0 Vertices");
  54     fDataLoaders->Add(v0DataLoader);
  55     v0DataLoader->SetEventFolder(fEventFolder);
  56     v0DataLoader->SetFolder(GetDetectorDataFolder());
  57
  58     AliDataLoader* cascadeDataLoader = new AliDataLoader(
  59         fDetectorName + ".Cascades.root",fgkDefaultCascadeContainerName,
  60         "Cascades");
  61     fDataLoaders->Add(cascadeDataLoader);
  62     cascadeDataLoader->SetEventFolder(fEventFolder);
  63     cascadeDataLoader->SetFolder(GetDetectorDataFolder());
  64 }
  65 /**********************************************************************/
  66 AliITSLoader::AliITSLoader(const Char_t *name,TFolder *topfolder):
  67 AliLoader(name,topfolder) {
  68   //ctor
  69     AliDataLoader*  rawClustersDataLoader = new AliDataLoader(
  70         fDetectorName + ".RawCl.root",fgkDefaultRawClustersContainerName,
  71         "Raw Clusters");
  72     fDataLoaders->Add(rawClustersDataLoader);
  73     rawClustersDataLoader->SetEventFolder(fEventFolder);
  74     rawClustersDataLoader->SetFolder(GetDetectorDataFolder());
  75
  76     AliDataLoader*  backTracksDataLoader =  new AliDataLoader(
  77         fDetectorName + ".BackTracks.root",fgkDefaultBackTracksContainerName,
  78         "Back Propagated Tracks");
  79     fDataLoaders->Add(backTracksDataLoader);
  80     backTracksDataLoader->SetEventFolder(fEventFolder);
  81     backTracksDataLoader->SetFolder(GetDetectorDataFolder());
  82
  83     AliDataLoader* vertexDataLoader = new AliDataLoader(
  84         fDetectorName + ".Vertex.root",fgkDefaultVerticesContainerName,
  85         "Primary Vertices","O");
  86     fDataLoaders->Add(vertexDataLoader);
  87     vertexDataLoader->SetEventFolder(fEventFolder);
  88     vertexDataLoader->SetFolder(GetDetectorDataFolder());
  89
  90     AliDataLoader* v0DataLoader = new AliDataLoader(
  91         fDetectorName + ".V0.root",fgkDefaultV0ContainerName,"V0 Vertices");
  92     fDataLoaders->Add(v0DataLoader);
  93     v0DataLoader->SetEventFolder(fEventFolder);
  94     v0DataLoader->SetFolder(GetDetectorDataFolder());
  95
  96     AliDataLoader* cascadeDataLoader = new AliDataLoader(
  97         fDetectorName + ".Cascade.root",fgkDefaultCascadeContainerName,
  98         "Cascades");
  99     fDataLoaders->Add(cascadeDataLoader);
 100     cascadeDataLoader->SetEventFolder(fEventFolder);
 101     cascadeDataLoader->SetFolder(GetDetectorDataFolder());
 102 }
 103 /**********************************************************************/
 104 AliITSLoader::~AliITSLoader(){
 105     //destructor
 106     AliDataLoader* dl = 0;
 107     UnloadRawClusters();
 108     dl = GetRawClLoader();
 109     fDataLoaders->Remove(dl);
 110
 111     UnloadBackTracks();
 112     dl = GetBackTracksDataLoader();
 113     fDataLoaders->Remove(dl);
 114
 115     UnloadVertices();
 116     dl = GetVertexDataLoader();
 117     fDataLoaders->Remove(dl);
 118
 119     UnloadV0s();
 120     dl = GetV0DataLoader();
 121     fDataLoaders->Remove(dl);
 122
 123     UnloadCascades();
 124     dl = GetCascadeDataLoader();
 125     fDataLoaders->Remove(dl);
 126 }
 127 //----------------------------------------------------------------------
 128 AliITS* AliITSLoader::GetITS(){
 129     // Returns the pointer to the ITS, kept on the file. A short cut metthod
 130     // Inputs:
 131     //    none.
 132     // Outputs:
 133     //    none.
 134     // Returns:
 135     //    Returns a pointer to the ITS, if not found returns 0.
 136     AliITS *its;
 137
 138     if(gAlice){
 139         its = dynamic_cast<AliITS*> (gAlice->GetDetector(
 140             GetDetectorName().Data()));
 141         if(its) return its;
 142     } // end if gAlice
 143     AliRunLoader *rl=0;
 144     rl = GetRunLoader();
 145     if(!rl) return 0;
 146     AliRun *ar=0;
 147     ar = rl->GetAliRun();
 148     if(!ar) return 0;
 149     its = dynamic_cast<AliITS*> (ar->GetDetector(GetDetectorName().Data()));
 150     return its;
 151 }
 152 //----------------------------------------------------------------------
 153 void AliITSLoader::SetupDigits(AliITS *its){
 154     // Sets up to store ITS Digits in side AliITS::fDtype TObjArray
 155     // Inputs:
 156     //    AliITS *its  Pointer to the ITS
 157     // Outputs:
 158     //    none.
 159     // Return:
 160     //    none.
 161
 162     its->SetTreeAddressD(TreeD());
 163 }
 164 //----------------------------------------------------------------------
 165 void AliITSLoader::SetupDigits(TObjArray *digPerDet,Int_t n,
 166                                const Char_t **digclass){
 167     // Sets up digPerDet to store ITS Digits.
 168     // Inputs:
 169     //    TObjArray *digPerDet   A pointer to a TObject Array size>=3.
 170     //    Int_t      n           The size of the TObjArray and digclass array
 171     //    Char_t     **digclass  Array of digit class names
 172     // Outputs:
 173     //    TObjArray *digPerDet   Setup and linked to the tree of digits
 174     // Return:
 175     //    none.
 176     Int_t i,m;
 177     TClonesArray *cl = 0;
 178     TTree *td = 0;
 179     TBranch *br = 0;
 180     Char_t branch[13];
 181     const Char_t *det[3] = {"SPD","SDD","SSD"};
 182
 183     if(!digPerDet){
 184         Error("SetUpDigits","TObject Array digPerDet does not exist");
 185         return;
 186     } // end if
 187     m = digPerDet->GetSize();
 188     if(m<n){
 189         Error("SetUpDigits","TObject Array digPerDet=%p must have a size"
 190               " at least that of n=%d",digPerDet,n);
 191     } // end if
 192     if(m<3){
 193         Error("SetUpDigits","TObject Array digPerDet=%p must have a size >2",
 194               digPerDet);
 195         return;
 196     } // end if
 197     td = TreeD();
 198     for(i=0;i<n;i++){
 199         if(digPerDet->At(i)==0){ // set up TClones Array
 200             digPerDet->AddAt(new TClonesArray(digclass[i],1000),i);
 201             if(n==3) sprintf(branch,"ITSDigits%s",det[i]);
 202             else     sprintf(branch,"ITSDigits%d",i+1);
 203             br = td->GetBranch(branch);
 204             br->SetAddress(&((*digPerDet)[i]));
 205             continue; // do next one.
 206         } // end if
 207         cl =  dynamic_cast<TClonesArray*> (digPerDet->At(i));
 208         if(!cl && digPerDet->At(i)!=0){  // not a TClonesArray
 209             Error("SetUpDigits","TObject Array digPerDet-At(%d)=%p must be "
 210                   "zeroed or filled with TClonesArrays",i,digPerDet);
 211             return;
 212         } // end if
 213         if(!(cl->GetClass()->GetBaseClass(AliITSdigit::Class()))){
 214             Error("SetUPDigits","TClones array at digPerDet[%d}=%p must be"
 215                   "derived from AliITSdigit",i,digPerDet->At(i));
 216         } // end if
 217         cl->Clear();
 218         if(n==3) sprintf(branch,"ITSDigits%s",det[i]);
 219         else     sprintf(branch,"ITSDigits%d",i+1);
 220         br = td->GetBranch(branch);
 221         br->SetAddress(&((*digPerDet)[i]));
 222         continue;
 223     } // end for i
 224 }
 225 //---------------------------------------------------------------------
 226 AliITSdigit * AliITSLoader::GetDigit(TObjArray *digPerDet,Int_t module,
 227                                      Int_t digit){
 228     // Gets the digit for for a specific detector type and module.
 229     // To be used in conjustion with Setupdigits(AliITS *its).
 230     // Inputs:
 231     //   TObjArray *digPereDet    Pointer to the Array of digits
 232     //   Int_t      module        Module number
 233     //   Int_t      digit         Digit number
 234     // Outputs:
 235     //   none.
 236     // Return:
 237     //   returns the pointer to the digit. if zero then last digit for that
 238     //   module.
 239
 240     if(digPerDet==0){
 241         Error("GetDigit","digPerDet=%p, module=%d, digit=%d",
 242               digPerDet,module,digit);
 243         return 0;
 244     } // end if
 245     return 0;
 246 }
 247 //---------------------------------------------------------------------
 248 AliITSdigit * AliITSLoader::GetDigit(AliITS *its,Int_t module,Int_t digit){
 249     // Gets the digit for for a specific detector type and module.
 250     // To be used in conjustion with Setupdigits(AliITS *its).
 251     // Inputs:
 252     //   AliITS *its    Pointer to the ITS
 253     //   Int_t  module  Module number
 254     //   Int_t digit    Digit number
 255     // Outputs:
 256     //   none.
 257     // Return:
 258     //   returns the pointer to the digit. if zero then last digit for that
 259     //   module.
 260     //AliITSDetType *idtype;
 261     AliITSgeom *geom = its->GetITSgeom();
 262     Int_t idet = geom->GetModuleType(module);
 263     TClonesArray *digits;
 264
 265     its->ResetDigits();
 266     TreeD()->GetEvent(module);
 267     digits = its->DigitsAddress(idet);
 268     if(digit>-1 && digit<digits->GetEntriesFast()){ // if in range.
 269         return (AliITSdigit*) digits->At(digit);
 270     } // end if
 271     return 0;
 272 }
 273 //----------------------------------------------------------------------
 274 void AliITSLoader::MakeTree(Option_t *opt){
 275     // invokes AliLoader::MakeTree + specific ITS tree(s)
 276     // Valid options: H,S,D,R,T and C (C=raw clusters)
 277     AliLoader::MakeTree(opt);
 278     const char *oC = strstr(opt,"C");
 279     if (oC) MakeRawClustersContainer();
 280
 281     const char *oB = strstr(opt,"B");
 282     if (oB) MakeBackTracksContainer();
 283
 284     const char *oV0 = strstr(opt,"V0");
 285     if (oV0) MakeV0Container();
 286
 287     const char *oX = strstr(opt,"X");
 288     if (oX) MakeCascadeContainer();
 289 }