ITS/AliITSLoader.cxx

   1 #include "AliITSdigit.h"
   2 #include "AliITSLoader.h"
   3 #include "AliRunLoader.h"
   4
   5 ///////////////////////////////////////////////////////////////////////////
   6 // Loader for ITS
   7 // it manages the I/O for:
   8 // raw clusters, primary vertices
   9 // V0 and cascade
  10 // and tracks propagated to the origin
  11 //////////////////////////////////////////////////////////////////////////
  12 const TString AliITSLoader::fgkDefaultRawClustersContainerName = "TreeC";
  13 const TString AliITSLoader::fgkDefaultBackTracksContainerName = "TreeB";
  14 const TString AliITSLoader::fgkDefaultVerticesContainerName = "Vertex";
  15 const TString AliITSLoader::fgkDefaultV0ContainerName = "V0";
  16 const TString AliITSLoader::fgkDefaultCascadeContainerName = "Cascade";
  17 ClassImp(AliITSLoader)
  18
  19 /**********************************************************************/
  20   AliITSLoader::AliITSLoader():AliLoader(){
  21   // Default constructor
  22   fITSpid = 0;
  23   fGeom = 0;
  24 }
  25 /*********************************************************************/
  26 AliITSLoader::AliITSLoader(const Char_t *name,const Char_t *topfoldername):
  27 AliLoader(name,topfoldername){
  28   //ctor
  29     AliDataLoader* rawClustersDataLoader = new AliDataLoader(
  30         fDetectorName + ".RawCl.root",fgkDefaultRawClustersContainerName,
  31         "Raw Clusters");
  32     fDataLoaders->Add(rawClustersDataLoader);
  33     rawClustersDataLoader->SetEventFolder(fEventFolder);
  34     rawClustersDataLoader->SetFolder(GetDetectorDataFolder());
  35
  36     AliDataLoader* backTracksDataLoader =  new AliDataLoader(
  37         fDetectorName + ".BackTracks.root",fgkDefaultBackTracksContainerName,
  38         "Back Propagated Tracks");
  39     fDataLoaders->Add(backTracksDataLoader);
  40     backTracksDataLoader->SetEventFolder(fEventFolder);
  41     backTracksDataLoader->SetFolder(GetDetectorDataFolder());
  42
  43     AliDataLoader* vertexDataLoader = new AliDataLoader(
  44         fDetectorName + ".Vertex.root",fgkDefaultVerticesContainerName,
  45         "Primary Vertices","O");
  46     fDataLoaders->Add(vertexDataLoader);
  47     vertexDataLoader->SetEventFolder(fEventFolder);
  48     vertexDataLoader->SetFolder(GetDetectorDataFolder());
  49
  50     AliDataLoader* v0DataLoader = new AliDataLoader(
  51         fDetectorName + ".V0s.root",fgkDefaultV0ContainerName,"V0 Vertices");
  52     fDataLoaders->Add(v0DataLoader);
  53     v0DataLoader->SetEventFolder(fEventFolder);
  54     v0DataLoader->SetFolder(GetDetectorDataFolder());
  55
  56     AliDataLoader* cascadeDataLoader = new AliDataLoader(
  57         fDetectorName + ".Cascades.root",fgkDefaultCascadeContainerName,
  58         "Cascades");
  59     fDataLoaders->Add(cascadeDataLoader);
  60     cascadeDataLoader->SetEventFolder(fEventFolder);
  61     cascadeDataLoader->SetFolder(GetDetectorDataFolder());
  62     fITSpid=0;
  63     fGeom = 0;
  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     fITSpid = 0;
 103     fGeom = 0;
 104 }
 105
 106 //______________________________________________________________________
 107 AliITSLoader::AliITSLoader(const AliITSLoader &ob) : AliLoader(ob) {
 108   // Copy constructor
 109   // Copies are not allowed. The method is protected to avoid misuse.
 110   Error("AliITSLoader","Copy constructor not allowed\n");
 111 }
 112
 113 //______________________________________________________________________
 114 AliITSLoader& AliITSLoader::operator=(const AliITSLoader& /* ob */){
 115   // Assignment operator
 116   // Assignment is not allowed. The method is protected to avoid misuse.
 117   Error("= operator","Assignment operator not allowed\n");
 118   return *this;
 119 }
 120
 121 /**********************************************************************/
 122 AliITSLoader::~AliITSLoader(){
 123     //destructor
 124     AliDataLoader* dl = 0;
 125     UnloadRawClusters();
 126     dl = GetRawClLoader();
 127     fDataLoaders->Remove(dl);
 128
 129     UnloadBackTracks();
 130     dl = GetBackTracksDataLoader();
 131     fDataLoaders->Remove(dl);
 132
 133     UnloadVertices();
 134     dl = GetVertexDataLoader();
 135     fDataLoaders->Remove(dl);
 136
 137     UnloadV0s();
 138     dl = GetV0DataLoader();
 139     fDataLoaders->Remove(dl);
 140
 141     UnloadCascades();
 142     dl = GetCascadeDataLoader();
 143     fDataLoaders->Remove(dl);
 144     if(fITSpid)delete fITSpid;
 145     if(fGeom)delete fGeom;
 146 }
 147 /*
 148 //----------------------------------------------------------------------
 149 AliITS* AliITSLoader::GetITS(){
 150     // Returns the pointer to the ITS, kept on the file. A short cut metthod
 151     // Inputs:
 152     //    none.
 153     // Outputs:
 154     //    none.
 155     // Returns:
 156     //    Returns a pointer to the ITS, if not found returns 0.
 157     AliITS *its;
 158
 159     if(gAlice){
 160         its = dynamic_cast<AliITS*> (gAlice->GetDetector(
 161             GetDetectorName().Data()));
 162         if(its) return its;
 163     } // end if gAlice
 164     AliRunLoader *rl=0;
 165     rl = GetRunLoader();
 166     if(!rl) return 0;
 167     AliRun *ar=0;
 168     ar = rl->GetAliRun();
 169     if(!ar) return 0;
 170     its = dynamic_cast<AliITS*> (ar->GetDetector(GetDetectorName().Data()));
 171     return its;
 172 }
 173 //----------------------------------------------------------------------
 174 void AliITSLoader::SetupDigits(AliITS *its){
 175     // Sets up to store ITS Digits in side AliITS::fDtype TObjArray
 176     // Inputs:
 177     //    AliITS *its  Pointer to the ITS
 178     // Outputs:
 179     //    none.
 180     // Return:
 181     //    none.
 182
 183     its->SetTreeAddressD(TreeD());
 184 }
 185 */
 186 //----------------------------------------------------------------------
 187 void AliITSLoader::SetupDigits(TObjArray *digPerDet,Int_t n,
 188                                const Char_t **digclass){
 189     // Sets up digPerDet to store ITS Digits.
 190     // Inputs:
 191     //    TObjArray *digPerDet   A pointer to a TObject Array size>=3.
 192     //    Int_t      n           The size of the TObjArray and digclass array
 193     //    Char_t     **digclass  Array of digit class names
 194     // Outputs:
 195     //    TObjArray *digPerDet   Setup and linked to the tree of digits
 196     // Return:
 197     //    none.
 198     Int_t i,m;
 199     TClonesArray *cl = 0;
 200     TTree *td = 0;
 201     TBranch *br = 0;
 202     Char_t branch[13];
 203     const Char_t *det[3] = {"SPD","SDD","SSD"};
 204
 205     if(!digPerDet){
 206         Error("SetUpDigits","TObject Array digPerDet does not exist");
 207         return;
 208     } // end if
 209     m = digPerDet->GetSize();
 210     if(m<n){
 211         Error("SetUpDigits","TObject Array digPerDet=%p must have a size"
 212               " at least that of n=%d",digPerDet,n);
 213     } // end if
 214     if(m<3){
 215         Error("SetUpDigits","TObject Array digPerDet=%p must have a size >2",
 216               digPerDet);
 217         return;
 218     } // end if
 219     td = TreeD();
 220     for(i=0;i<n;i++){
 221         if(digPerDet->At(i)==0){ // set up TClones Array
 222             digPerDet->AddAt(new TClonesArray(digclass[i],1000),i);
 223             if(n==3) sprintf(branch,"ITSDigits%s",det[i]);
 224             else     sprintf(branch,"ITSDigits%d",i+1);
 225             br = td->GetBranch(branch);
 226             br->SetAddress(&((*digPerDet)[i]));
 227             continue; // do next one.
 228         } // end if
 229         cl =  dynamic_cast<TClonesArray*> (digPerDet->At(i));
 230         if(!cl && digPerDet->At(i)!=0){  // not a TClonesArray
 231             Error("SetUpDigits","TObject Array digPerDet-At(%d)=%p must be "
 232                   "zeroed or filled with TClonesArrays",i,digPerDet);
 233             return;
 234         } // end if
 235         if(!(cl->GetClass()->GetBaseClass(AliITSdigit::Class()))){
 236             Error("SetUPDigits","TClones array at digPerDet[%d}=%p must be"
 237                   "derived from AliITSdigit",i,digPerDet->At(i));
 238         } // end if
 239         cl->Clear();
 240         if(n==3) sprintf(branch,"ITSDigits%s",det[i]);
 241         else     sprintf(branch,"ITSDigits%d",i+1);
 242         br = td->GetBranch(branch);
 243         br->SetAddress(&((*digPerDet)[i]));
 244         continue;
 245     } // end for i
 246 }
 247 //---------------------------------------------------------------------
 248 AliITSdigit * AliITSLoader::GetDigit(TObjArray *digPerDet,Int_t module,
 249                                      Int_t digit){
 250     // Gets the digit for for a specific detector type and module.
 251     // To be used in conjustion with Setupdigits(AliITS *its).
 252     // Inputs:
 253     //   TObjArray *digPereDet    Pointer to the Array of digits
 254     //   Int_t      module        Module number
 255     //   Int_t      digit         Digit number
 256     // Outputs:
 257     //   none.
 258     // Return:
 259     //   returns the pointer to the digit. if zero then last digit for that
 260     //   module.
 261
 262     if(digPerDet==0){
 263         Error("GetDigit","digPerDet=%p, module=%d, digit=%d",
 264               digPerDet,module,digit);
 265         return 0;
 266     } // end if
 267     return 0;
 268 }
 269 /*
 270 //---------------------------------------------------------------------
 271 AliITSdigit * AliITSLoader::GetDigit(AliITS *its,Int_t module,Int_t digit){
 272     // Gets the digit for for a specific detector type and module.
 273     // To be used in conjustion with Setupdigits(AliITS *its).
 274     // Inputs:
 275     //   AliITS *its    Pointer to the ITS
 276     //   Int_t  module  Module number
 277     //   Int_t digit    Digit number
 278     // Outputs:
 279     //   none.
 280     // Return:
 281     //   returns the pointer to the digit. if zero then last digit for that
 282     //   module.
 283     //AliITSDetType *idtype;
 284     AliITSgeom *geom = its->GetITSgeom();
 285     Int_t idet = geom->GetModuleType(module);
 286     TClonesArray *digits;
 287
 288     its->ResetDigits();
 289     TreeD()->GetEvent(module);
 290     digits = its->DigitsAddress(idet);
 291     if(digit>-1 && digit<digits->GetEntriesFast()){ // if in range.
 292         return (AliITSdigit*) digits->At(digit);
 293     } // end if
 294     return 0;
 295 }
 296 */
 297 //----------------------------------------------------------------------
 298 void AliITSLoader::MakeTree(Option_t *opt){
 299     // invokes AliLoader::MakeTree + specific ITS tree(s)
 300     // Valid options: H,S,D,R,T and C (C=raw clusters)
 301     AliLoader::MakeTree(opt);
 302     const char *oC = strstr(opt,"C");
 303     if (oC) MakeRawClustersContainer();
 304
 305     const char *oB = strstr(opt,"B");
 306     if (oB) MakeBackTracksContainer();
 307
 308     const char *oV0 = strstr(opt,"V0");
 309     if (oV0) MakeV0Container();
 310
 311     const char *oX = strstr(opt,"X");
 312     if (oX) MakeCascadeContainer();
 313 }
 314
 315 //----------------------------------------------------------------------
 316 AliITSgeom* AliITSLoader::GetITSgeom(Bool_t force) {
 317   // retrieves the ITS geometry from file
 318   if(fGeom && !force)return fGeom;
 319   if(fGeom && force){
 320     delete fGeom;
 321     fGeom = 0;
 322   }
 323   AliRunLoader *runLoader = GetRunLoader();
 324   if (!runLoader->GetAliRun()) runLoader->LoadgAlice();
 325   if (!runLoader->GetAliRun()) {
 326     Error("GetITSgeom", "couldn't get AliRun object");
 327     return NULL;
 328   }
 329
 330   TDirectory *curdir = gDirectory;
 331   runLoader->CdGAFile();
 332   fGeom = (AliITSgeom*)gDirectory->Get("AliITSgeom");
 333   curdir->cd();
 334   if(!fGeom){
 335     Error("GetITSgeom","no ITS geometry available");
 336     return NULL;
 337   }
 338
 339   return fGeom;
 340 }
 341