ITS/AliITSreconstruction.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17 /////////////////////////////////////////////////////////////////////////
  18 //                                                                     //
  19 // Class for ITS RecPoint reconstruction                               //
  20 //                                                                     //
  21 ////////////////////////////////////////////////////////////////////////
  22
  23 #include <TString.h>
  24 #include "AliRun.h"
  25 #include "AliRunLoader.h"
  26 #include "AliITSDetTypeRec.h"
  27 #include "AliITSLoader.h"
  28 #include "AliITSreconstruction.h"
  29 #include "AliITSgeom.h"
  30
  31
  32 ClassImp(AliITSreconstruction)
  33
  34 //______________________________________________________________________
  35 AliITSreconstruction::AliITSreconstruction():
  36  fInit(kFALSE),
  37  fEnt(0),
  38  fEnt0(0),
  39  fDetTypeRec(0x0),
  40  fDfArp(kFALSE),
  41  fITSgeom(0x0),
  42  fLoader(0x0),
  43  fRunLoader(0x0)
  44 {
  45     // Default constructor.
  46     // Inputs:
  47     //  none.
  48     // Outputs:
  49     //   none.
  50     // Return:
  51     //    A zero-ed constructed AliITSreconstruction class.
  52     fDet[0] = fDet[1] = fDet[2] = kTRUE;
  53 }
  54 //______________________________________________________________________
  55
  56 AliITSreconstruction::AliITSreconstruction(AliRunLoader *rl):
  57  fInit(kFALSE),
  58  fEnt(0),
  59  fEnt0(0),
  60  fDetTypeRec(0x0),
  61  fDfArp(kFALSE),
  62  fITSgeom(0x0),
  63  fLoader(0x0),
  64  fRunLoader(rl)
  65 {
  66   fDet[0] = fDet[1] = fDet[2] = kTRUE;
  67 }
  68 //______________________________________________________________________
  69 AliITSreconstruction::AliITSreconstruction(const char* filename):
  70  fInit(kFALSE),
  71  fEnt(0),
  72  fEnt0(0),
  73  fDetTypeRec(0x0),
  74  fDfArp(kFALSE),
  75  fITSgeom(0x0),
  76  fLoader(0x0),
  77  fRunLoader(0x0)
  78 {
  79     // Standard constructor.
  80     // Inputs:
  81     //  const char* filename    filename containing the digits to be
  82     //                          reconstructed. If filename = 0 (nil)
  83     //                          then no file is opened but a file is
  84     //                          assumed to already be opened. This
  85     //                          already opened file will be used.
  86     // Outputs:
  87     //   none.
  88     // Return:
  89     //    A standardly constructed AliITSreconstruction class.
  90
  91     fDet[0] = fDet[1] = fDet[2] = kTRUE;
  92
  93     fRunLoader = AliRunLoader::Open(filename);
  94     if (fRunLoader == 0x0)
  95      {
  96        Error("AliITSreconstruction","Can not load the session",filename);
  97        return;
  98      }
  99     fRunLoader->LoadgAlice();
 100     gAlice = fRunLoader->GetAliRun();
 101
 102     if(!gAlice) {
 103           Error("AliITSreconstruction","gAlice not found on file. Aborting.");
 104           fInit = kFALSE;
 105           return;
 106       } // end if !gAlice
 107
 108 }
 109
 110 //______________________________________________________________________
 111 AliITSreconstruction::AliITSreconstruction(const AliITSreconstruction &rec):TTask(rec),
 112 fInit(rec.fInit),
 113 fEnt(rec.fEnt),
 114 fEnt0(rec.fEnt0),
 115 fDetTypeRec(rec.fDetTypeRec),
 116 fDfArp(rec.fDfArp),
 117 fITSgeom(rec.fITSgeom),
 118 fLoader(rec.fLoader),
 119 fRunLoader(rec.fRunLoader)
 120 {
 121     // Copy constructor.
 122
 123
 124 }
 125
 126 //______________________________________________________________________
 127 AliITSreconstruction& AliITSreconstruction::operator=(const AliITSreconstruction& source){
 128     // Assignment operator.
 129   this->~AliITSreconstruction();
 130   new(this) AliITSreconstruction(source);
 131   return *this;
 132
 133 }
 134
 135 //______________________________________________________________________
 136 AliITSreconstruction::~AliITSreconstruction(){
 137     //    A destroyed AliITSreconstruction class.
 138
 139     //fITS      = 0;
 140     delete fRunLoader;
 141
 142 }
 143 //______________________________________________________________________
 144 Bool_t AliITSreconstruction::Init(){
 145     // Class Initilizer.
 146     // Inputs:
 147     //  none.
 148     // Outputs:
 149     //   none.
 150     // Return:
 151     //    kTRUE if no errors initilizing this class occurse else kFALSE
 152     Info("Init","");
 153     if (fRunLoader == 0x0)
 154      {
 155        Error("Init","Run Loader is NULL");
 156        return kFALSE;
 157      }
 158     fRunLoader->LoadgAlice();
 159     fRunLoader->LoadHeader();
 160
 161     fLoader = (AliITSLoader*) fRunLoader->GetLoader("ITSLoader");
 162     if(!fLoader) {
 163       Error("Init","ITS loader not found");
 164       fInit = kFALSE;
 165     }
 166
 167     // Now ready to init.
 168
 169     fRunLoader->CdGAFile();
 170     fITSgeom = fLoader->GetITSgeom();
 171
 172     fDetTypeRec = new AliITSDetTypeRec(fLoader);
 173     fDetTypeRec->SetDefaults();
 174     fDet[0] = fDet[1] = fDet[2] = kTRUE;
 175     fEnt0 = 0;
 176
 177     //fEnt  = gAlice->GetEventsPerRun();
 178     fEnt = Int_t(fRunLoader->TreeE()->GetEntries());
 179
 180     fLoader->LoadDigits("read");
 181     fLoader->LoadRecPoints("recreate");
 182     fLoader->LoadRawClusters("recreate");
 183     if (fLoader->TreeR() == 0x0) fLoader->MakeTree("R");
 184     if (fLoader->TreeC() == 0x0) fLoader->MakeTree("C");
 185
 186     fDetTypeRec->MakeBranchR(0);
 187     fDetTypeRec->MakeBranchC();
 188     fDetTypeRec->SetTreeAddress();
 189     fDetTypeRec->SetTreeAddressR(fLoader->TreeR());
 190
 191     fInit = InitRec();
 192
 193     Info("Init","  Done\n\n\n");
 194
 195     return fInit;
 196 }
 197 //______________________________________________________________________
 198 Bool_t AliITSreconstruction::InitRec(){
 199     // Sets up Reconstruction part of AliITSDetType..
 200     // Inputs:
 201     //      none.
 202     // Outputs:
 203     //      none.
 204     // Return:
 205     //      none.
 206   /*
 207   //AliITSDetType *idt;
 208   fDetTypeRec->SetLoader(fLoader);
 209     // SPD
 210   if(fDet[kSPD]){
 211     Info("InitRec","SPD");
 212     //idt = fITS->DetType(kSPD);
 213     AliITSsegmentationSPD *segSPD = (AliITSsegmentationSPD*)fDetTypeRec->GetSegmentationModel(0);
 214       TClonesArray *digSPD = fDetTypeRec->DigitsAddress(kSPD);
 215       TClonesArray *recpSPD = fDetTypeRec->ClustersAddress(kSPD);
 216       Info("InitRec","idt = %#x; digSPD = %#x; recpSPD = %#x",fDetTypeRec,digSPD,recpSPD);
 217       AliITSClusterFinderSPD *recSPD = new AliITSClusterFinderSPD(segSPD,digSPD,recpSPD);
 218       fDetTypeRec->SetReconstructionModel(kSPD,recSPD);
 219     } // end if fDet[kSPD].
 220   // SDD
 221   if(fDet[kSDD]){
 222     Info("InitRec","SDD");
 223     //    idt = fITS->DetType(kSDD);
 224     AliITSsegmentationSDD *segSDD = (AliITSsegmentationSDD*)
 225       fDetTypeRec->GetSegmentationModel(1);
 226     AliITSresponseSDD *resSDD = (AliITSresponseSDD*)
 227       fDetTypeRec->GetCalibrationModel(fDetTypeRec->GetITSgeom()->GetStartSDD());
 228     TClonesArray *digSDD = fDetTypeRec->DigitsAddress(kSDD);
 229     TClonesArray *recpSDD = fDetTypeRec->ClustersAddress(kSDD);
 230     AliITSClusterFinderSDD *recSDD =new AliITSClusterFinderSDD(segSDD,
 231                                                                resSDD,
 232                                                                digSDD,recpSDD);
 233     fDetTypeRec->SetReconstructionModel(kSDD,recSDD);
 234   } // end if fDet[kSDD]
 235     // SSD
 236   if(fDet[kSSD]){
 237     Info("InitRec","SSD");
 238     //idt = fITS->DetType(kSSD);
 239     AliITSsegmentationSSD *segSSD = (AliITSsegmentationSSD*)
 240                                        fDetTypeRec->GetSegmentationModel(2);
 241       TClonesArray *digSSD = fDetTypeRec->DigitsAddress(kSSD);
 242       AliITSClusterFinderSSD *recSSD =new AliITSClusterFinderSSD(segSSD,
 243                                                                  digSSD);
 244       recSSD->SetITSgeom(fDetTypeRec->GetITSgeom());
 245       fDetTypeRec->SetReconstructionModel(kSSD,recSSD);
 246     } // end if fDet[kSSD]
 247   */
 248   fDetTypeRec->SetDefaultClusterFinders();
 249     Info("InitRec","    Done\n");
 250     return kTRUE;
 251 }
 252 //______________________________________________________________________
 253 void AliITSreconstruction::Exec(const Option_t *opt){
 254     // Main reconstruction function.
 255     // Inputs:
 256     //      Option_t * opt   list of subdetector to digitize. =0 all.
 257     // Outputs:
 258     //      none.
 259     // Return:
 260     //      none.
 261     Option_t *lopt;
 262     Int_t evnt;
 263
 264     if(strstr(opt,"All")||strstr(opt,"ALL")||strstr(opt,"ITS")||opt==0){
 265       fDet[0] = fDet[1] = fDet[2] = kTRUE;
 266       lopt = "All";
 267     }else{
 268       fDet[0] = fDet[1] = fDet[2] = kFALSE;
 269       if(strstr(opt,"SPD")) fDet[kSPD] = kTRUE;
 270       if(strstr(opt,"SDD")) fDet[kSDD] = kTRUE;
 271       if(strstr(opt,"SSD")) fDet[kSSD] = kTRUE;
 272       if(fDet[kSPD] && fDet[kSDD] && fDet[kSSD]) lopt = "All";
 273       else lopt = opt;
 274     } // end if strstr(opt,...)
 275
 276     if(!fInit){
 277       cout << "Initilization Failed, Can't run Exec." << endl;
 278       return;
 279     } // end if !fInit
 280     for(evnt=0;evnt<fEnt;evnt++)
 281      {
 282       Info("Exec","");
 283       Info("Exec","Processing Event %d",evnt);
 284       Info("Exec","");
 285
 286       fRunLoader->GetEvent(evnt);
 287       if (fLoader->TreeR() == 0x0) fLoader->MakeTree("R");
 288       fDetTypeRec->MakeBranchR(0);
 289       if (fLoader->TreeC() == 0x0){
 290         fDetTypeRec->MakeTreeC();
 291         fDetTypeRec->MakeBranchC();
 292       }
 293       fDetTypeRec->SetTreeAddressR(fLoader->TreeR());
 294       fDetTypeRec->SetTreeAddressD(fLoader->TreeD());
 295       fDetTypeRec->DigitsToRecPoints(evnt,0,lopt);
 296     } // end for evnt
 297 }
 298 //______________________________________________________________________
 299 void AliITSreconstruction::SetOutputFile(TString filename){
 300   // Set a new file name for recpoints.
 301   // It must be called before Init()
 302   if(!fLoader)fLoader = (AliITSLoader*) fRunLoader->GetLoader("ITSLoader");
 303   if(fLoader){
 304     Info("SetOutputFile","name for rec points is %s",filename.Data());
 305     fLoader->SetRecPointsFileName(filename);
 306   }
 307   else {
 308     Error("SetOutputFile",
 309     "ITS loader not available. Not possible to set name: %s",filename.Data());
 310   }
 311 }