]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - ITS/AliITS.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Radiator to Pad goes static.
[u/mrichter/AliRoot.git] / ITS / AliITS.cxx
... / ...
CommitLineData
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///////////////////////////////////////////////////////////////////////////////
20//
21// An overview of the basic philosophy of the ITS code development
22// and analysis is show in the figure below.
23//Begin_Html
24/*
25<img src="picts/ITS/ITS_Analysis_schema.gif">
26</pre>
27<br clear=left>
28<font size=+2 color=red>
29<p>Roberto Barbera is in charge of the ITS Offline code (1999).
30<a href="mailto:roberto.barbera@ct.infn.it">Roberto Barbera</a>.
31</font>
32<pre>
33*/
34//End_Html
35//
36// AliITS. Inner Traking System base class.
37// This class contains the base procedures for the Inner Tracking System
38//
39//Begin_Html
40/*
41<img src="picts/ITS/AliITS_Class_Diagram.gif">
42</pre>
43<br clear=left>
44<font size=+2 color=red>
45<p>This show the class diagram of the different elements that are part of
46the AliITS class.
47</font>
48<pre>
49*/
50//End_Html
51//
52// Version: 0
53// Written by Rene Brun, Federico Carminati, and Roberto Barbera
54//
55// Version: 1
56// Modified and documented by Bjorn S. Nilsen
57// July 11 1999
58//
59// Version: 2
60// Modified and documented by A. Bologna
61// October 18 1999
62//
63// AliITS is the general base class for the ITS. Also see AliDetector for
64// futher information.
65//
66///////////////////////////////////////////////////////////////////////////////
67
68#include <Riostream.h>
69#include <stdlib.h>
70
71#include <TBranch.h>
72#include <TClonesArray.h>
73#include <TFile.h>
74#include <TMath.h>
75#include <TObjectTable.h>
76#include <TROOT.h>
77#include <TRandom.h>
78#include <TString.h>
79#include <TTree.h>
80#include <TVector.h>
81#include <TVirtualMC.h>
82
83#include "AliConfig.h"
84#include "AliHeader.h"
85#include "AliITS.h"
86#include "AliITSClusterFinderSDD.h"
87#include "AliITSClusterFinderSPD.h"
88#include "AliITSClusterFinderSSD.h"
89#include "AliITSDetType.h"
90#include "AliITSLoader.h"
91#include "AliITSRawCluster.h"
92#include "AliITSRecPoint.h"
93#include "AliITSdigit.h"
94#include "AliITSgeom.h"
95#include "AliITShit.h"
96#include "AliITSmodule.h"
97#include "AliITSpList.h"
98#include "AliITSresponseSDD.h"
99#include "AliITSresponseSPD.h"
100#include "AliITSresponseSSD.h"
101#include "AliITSsegmentationSDD.h"
102#include "AliITSsegmentationSPD.h"
103#include "AliITSsegmentationSSD.h"
104#include "AliITSsimulationSDD.h"
105#include "AliITSsimulationSPD.h"
106#include "AliITSsimulationSSD.h"
107
108ClassImp(AliITS)
109
110//______________________________________________________________________
111AliITS::AliITS() : AliDetector() {
112 // Default initializer for ITS
113 // The default constructor of the AliITS class. In addition to
114 // creating the AliITS class it zeros the variables fIshunt (a member
115 // of AliDetector class), fEuclidOut, and fIdN, and zeros the pointers
116 // fITSpoints, fIdSens, and fIdName. The AliDetector default constructor
117 // is also called.
118 // Inputs:
119 // none.
120 // Outputs:
121 // none.
122 // Return:
123 // Blank ITS class.
124
125 fIshunt = 0; // not zeroed in AliDetector.
126
127 // AliITS variables.
128 fEuclidOut = 0;
129 fITSgeom = 0;
130 fITSmodules = 0;
131 fOpt = "All";
132// SetDetectors(); // default to fOpt="All". This variable not written out.
133
134 fIdN = 0;
135 fIdName = 0;
136 fIdSens = 0;
137
138 fNDetTypes = kNTYPES;
139 fDetTypes = 0;
140
141 fSDigits = 0;
142 fNSDigits = 0;
143
144 fNdtype = 0;
145 fDtype = 0;
146
147 fCtype = 0;
148 fNctype = 0;
149
150 fRecPoints = 0;
151 fNRecPoints = 0;
152
153 SetMarkerColor(kRed);
154}
155//______________________________________________________________________
156AliITS::AliITS(const char *name, const char *title):AliDetector(name,title){
157 // The standard Constructor for the ITS class. In addition to
158 // creating the AliITS class, it allocates memory for the TClonesArrays
159 // fHits, fSDigits, fDigits, fITSpoints, and the TObjArray of fCtype
160 // (clusters). It also zeros the variables
161 // fIshunt (a member of AliDetector class), fEuclidOut, and fIdN, and zeros
162 // the pointers fIdSens and fIdName. To help in displaying hits via the
163 // ROOT macro display.C AliITS also sets the marker color to red. The
164 // variables passes with this constructor, const char *name and *title,
165 // are used by the constructor of AliDetector class. See AliDetector
166 // class for a description of these parameters and its constructor
167 // functions.
168 // Inputs:
169 // const char *name Detector name. Should always be "ITS"
170 // const char *title Detector title.
171 // Outputs:
172 // none.
173 // Return:
174 // An ITS class.
175
176 fIshunt = 0; // not zeroed in AliDetector
177 fHits = new TClonesArray("AliITShit", 1560);//not done in AliDetector
178 gAlice->AddHitList(fHits); // Not done in AliDetector.
179
180 fEuclidOut = 0;
181 fITSgeom = 0;
182 fITSmodules = 0;
183 SetDetectors(); // default to fOpt="All". This variable not written out.
184
185 fIdN = 0;
186 fIdName = 0;
187 fIdSens = 0;
188
189 fNDetTypes = kNTYPES;
190 fDetTypes = new TObjArray(fNDetTypes);
191
192 fSDigits = new TClonesArray("AliITSpListItem",1000);
193 fNSDigits = 0;
194
195 fNdtype = new Int_t[fNDetTypes];
196 fDtype = new TObjArray(fNDetTypes);
197
198 fCtype = new TObjArray(fNDetTypes);
199 fNctype = new Int_t[fNDetTypes];
200
201 fRecPoints = new TClonesArray("AliITSRecPoint",1000);
202 fNRecPoints = 0;
203
204 Int_t i;
205 for(i=0;i<fNDetTypes;i++) {
206 fDetTypes->AddAt(new AliITSDetType(),i);
207 fNdtype[i] = 0;
208 fNctype[i] = 0;
209 } // end for i
210
211 SetMarkerColor(kRed);
212
213}
214//______________________________________________________________________
215AliITS::~AliITS(){
216 // Default destructor for ITS.
217 // The default destructor of the AliITS class. In addition to deleting
218 // the AliITS class it deletes the memory pointed to by the fHits, fDigits,
219 // fSDigits, fCtype, fITSmodules, fITSgeom, fRecPoints, fIdSens, fIdName,
220 // fITSpoints, fDetType and it's contents.
221 // Inputs:
222 // none.
223 // Outputs:
224 // none.
225 // Return:
226 // none.
227
228 if (fHits) {
229 fHits->Delete();
230 delete fHits;
231 fHits=0;
232 }
233 if (fSDigits) {
234 fSDigits->Delete();
235 delete fSDigits;
236 fSDigits=0;
237 }
238 if (fDigits) {
239 fDigits->Delete();
240 delete fDigits;
241 fDigits=0;
242 }
243 if (fRecPoints) {
244 fRecPoints->Delete();
245 delete fRecPoints;
246 fRecPoints=0;
247 }
248 delete[] fIdName; // Array of TStrings
249 delete[] fIdSens;
250 if(fITSmodules) {
251 this->ClearModules();
252 delete fITSmodules;
253 fITSmodules = 0;
254 }// end if fITSmodules!=0
255
256 if(fDtype) {
257 fDtype->Delete();
258 delete fDtype;
259 } // end if fDtype
260 delete [] fNdtype;
261 if (fCtype) {
262 fCtype->Delete();
263 delete fCtype;
264 fCtype = 0;
265 } // end if fCtype
266 delete [] fNctype;
267
268 if (fDetTypes) {
269 fDetTypes->Delete();
270 delete fDetTypes;
271 fDetTypes = 0;
272 } // end if fDetTypes
273
274
275 if (fITSgeom) delete fITSgeom;
276}
277//______________________________________________________________________
278AliITS::AliITS(const AliITS &source) : AliDetector(source){
279 // Copy constructor. This is a function which is not allowed to be
280 // done to the ITS. It exits with an error.
281 // Inputs:
282 // AliITS &source An AliITS class.
283 // Outputs:
284 // none.
285 // Return:
286 // none.
287
288 if(this==&source) return;
289 Error("Copy constructor",
290 "You are not allowed to make a copy of the AliITS");
291 exit(1);
292}
293//______________________________________________________________________
294AliITS& AliITS::operator=(AliITS &source){
295 // Assignment operator. This is a function which is not allowed to be
296 // done to the ITS. It exits with an error.
297 // Inputs:
298 // AliITS &source An AliITS class.
299 // Outputs:
300 // none.
301 // Return:
302 // none.
303
304 if(this==&source) return *this;
305 Error("operator=","You are not allowed to make a copy of the AliITS");
306 exit(1);
307 return *this; //fake return
308}
309//______________________________________________________________________
310Int_t AliITS::DistancetoPrimitive(Int_t,Int_t) const{
311 // Distance from mouse to ITS on the screen. Dummy routine
312 // A dummy routine used by the ROOT macro display.C to allow for the
313 // use of the mouse (pointing device) in the macro. In general this should
314 // never be called. If it is it returns the number 9999 for any value of
315 // x and y.
316 // Inputs:
317 // Int_t Dummy screen coordinate.
318 // Int_t Dummy screen coordinate.
319 // Outputs:
320 // none.
321 // Return:
322 // Int_t Dummy = 9999 distance to ITS.
323
324 return 9999;
325}
326//______________________________________________________________________
327void AliITS::Init(){
328 // Initializer ITS after it has been built
329 // This routine initializes the AliITS class. It is intended to be
330 // called from the Init function in AliITSv?. Besides displaying a banner
331 // indicating that it has been called it initializes the array fIdSens
332 // and sets the default segmentation, response, digit and raw cluster
333 // classes therefore it should be called after a call to CreateGeometry.
334 // Inputs:
335 // none.
336 // Outputs:
337 // none.
338 // Return:
339 // none.
340 Int_t i;
341
342 SetDefaults();
343 // Array of TStrings
344 for(i=0;i<fIdN;i++) fIdSens[i] = gMC->VolId(fIdName[i]);
345}
346//______________________________________________________________________
347void AliITS::SetDefaults(){
348 // sets the default segmentation, response, digit and raw cluster classes.
349 // Inputs:
350 // none.
351 // Outputs:
352 // none.
353 // Return:
354 // none.
355
356 if(fDebug) printf("%s: SetDefaults\n",ClassName());
357
358 AliITSDetType *iDetType;
359
360 //SPD
361 iDetType=DetType(0);
362 if (!iDetType->GetSegmentationModel()) {
363 AliITSsegmentationSPD *seg0=new AliITSsegmentationSPD(fITSgeom);
364 SetSegmentationModel(0,seg0);
365 } // end if
366 if (!iDetType->GetResponseModel()) {
367 SetResponseModel(0,new AliITSresponseSPD());
368 } // end if
369 // set digit and raw cluster classes to be used
370
371 const char *kData0=(iDetType->GetResponseModel())->DataType();
372 if (strstr(kData0,"real")) {
373 iDetType->ClassNames("AliITSdigit","AliITSRawClusterSPD");
374 } else iDetType->ClassNames("AliITSdigitSPD","AliITSRawClusterSPD");
375
376 // SDD
377 iDetType=DetType(1);
378 if (!iDetType->GetResponseModel()) {
379 SetResponseModel(1,new AliITSresponseSDD("simulated"));
380 } // end if
381 AliITSresponse *resp1=iDetType->GetResponseModel();
382 if (!iDetType->GetSegmentationModel()) {
383 AliITSsegmentationSDD *seg1=new AliITSsegmentationSDD(fITSgeom,resp1);
384 SetSegmentationModel(1,seg1);
385 } // end if
386 const char *kData1=(iDetType->GetResponseModel())->DataType();
387 const char *kopt=iDetType->GetResponseModel()->ZeroSuppOption();
388 if((!strstr(kopt,"2D"))&&(!strstr(kopt,"1D")) || strstr(kData1,"real") ){
389 iDetType->ClassNames("AliITSdigit","AliITSRawClusterSDD");
390 } else iDetType->ClassNames("AliITSdigitSDD","AliITSRawClusterSDD");
391
392 // SSD
393 iDetType=DetType(2);
394 if (!iDetType->GetSegmentationModel()) {
395 AliITSsegmentationSSD *seg2=new AliITSsegmentationSSD(fITSgeom);
396 SetSegmentationModel(2,seg2);
397 } // end if
398 if (!iDetType->GetResponseModel()) {
399 SetResponseModel(2,new AliITSresponseSSD("simulated"));
400 } // end if
401 const char *kData2=(iDetType->GetResponseModel())->DataType();
402 if (strstr(kData2,"real")) {
403 iDetType->ClassNames("AliITSdigit","AliITSRawClusterSSD");
404 } else iDetType->ClassNames("AliITSdigitSSD","AliITSRawClusterSSD");
405
406 if (kNTYPES>3) {
407 Warning("SetDefaults",
408 "Only the three basic detector types are initialized!");
409 } // end if
410}
411//______________________________________________________________________
412void AliITS::SetDefaultSimulation(){
413 // sets the default simulation.
414 // Inputs:
415 // none.
416 // Outputs:
417 // none.
418 // Return:
419 // none.
420
421 AliITSDetType *iDetType;
422 AliITSsimulation *sim;
423 iDetType=DetType(0);
424 sim = iDetType->GetSimulationModel();
425 if (!sim) {
426 AliITSsegmentation *seg0=
427 (AliITSsegmentation*)iDetType->GetSegmentationModel();
428 AliITSresponse *res0 = (AliITSresponse*)iDetType->GetResponseModel();
429 AliITSsimulationSPD *sim0=new AliITSsimulationSPD(seg0,res0);
430 SetSimulationModel(0,sim0);
431 }else{ // simulation exists, make sure it is set up properly.
432 ((AliITSsimulationSPD*)sim)->Init(
433 (AliITSsegmentationSPD*) iDetType->GetSegmentationModel(),
434 (AliITSresponseSPD*) iDetType->GetResponseModel());
435// if(sim->GetResponseModel()==0) sim->SetResponseModel(
436// (AliITSresponse*)iDetType->GetResponseModel());
437// if(sim->GetSegmentationModel()==0) sim->SetSegmentationModel(
438// (AliITSsegmentation*)iDetType->GetSegmentationModel());
439 } // end if
440 iDetType=DetType(1);
441 sim = iDetType->GetSimulationModel();
442 if (!sim) {
443 AliITSsegmentation *seg1=
444 (AliITSsegmentation*)iDetType->GetSegmentationModel();
445 AliITSresponse *res1 = (AliITSresponse*)iDetType->GetResponseModel();
446 AliITSsimulationSDD *sim1=new AliITSsimulationSDD(seg1,res1);
447 SetSimulationModel(1,sim1);
448 }else{ // simulation exists, make sure it is set up properly.
449 ((AliITSsimulationSDD*)sim)->Init(
450 (AliITSsegmentationSDD*) iDetType->GetSegmentationModel(),
451 (AliITSresponseSDD*) iDetType->GetResponseModel());
452// if(sim->GetResponseModel()==0) sim->SetResponseModel(
453// (AliITSresponse*)iDetType->GetResponseModel());
454// if(sim->GetSegmentationModel()==0) sim->SetSegmentationModel(
455// (AliITSsegmentation*)iDetType->GetSegmentationModel());
456 } //end if
457 iDetType=DetType(2);
458 sim = iDetType->GetSimulationModel();
459 if (!sim) {
460 AliITSsegmentation *seg2=
461 (AliITSsegmentation*)iDetType->GetSegmentationModel();
462 AliITSresponse *res2 = (AliITSresponse*)iDetType->GetResponseModel();
463 AliITSsimulationSSD *sim2=new AliITSsimulationSSD(seg2,res2);
464 SetSimulationModel(2,sim2);
465 }else{ // simulation exists, make sure it is set up properly.
466 ((AliITSsimulationSSD*)sim)->Init(
467 (AliITSsegmentationSSD*) iDetType->GetSegmentationModel(),
468 (AliITSresponseSSD*) iDetType->GetResponseModel());
469// if(sim->GetResponseModel()==0) sim->SetResponseModel(
470// (AliITSresponse*)iDetType->GetResponseModel());
471// if(sim->GetSegmentationModel()==0) sim->SetSegmentationModel(
472// (AliITSsegmentation*)iDetType->GetSegmentationModel());
473 } // end if
474}
475//______________________________________________________________________
476void AliITS::SetDefaultClusterFinders(){
477 // Sets the default cluster finders. Used in finding RecPoints.
478 // Inputs:
479 // none.
480 // Outputs:
481 // none.
482 // Return:
483 // none.
484
485 MakeTreeC();
486 AliITSDetType *iDetType;
487
488 // SPD
489 iDetType=DetType(0);
490 if (!iDetType->GetReconstructionModel()) {
491 AliITSsegmentation *seg0 =
492 (AliITSsegmentation*)iDetType->GetSegmentationModel();
493 TClonesArray *dig0=DigitsAddress(0);
494 TClonesArray *recp0=ClustersAddress(0);
495 AliITSClusterFinderSPD *rec0 = new AliITSClusterFinderSPD(seg0,dig0,
496 recp0);
497 SetReconstructionModel(0,rec0);
498 } // end if
499
500 // SDD
501 iDetType=DetType(1);
502 if (!iDetType->GetReconstructionModel()) {
503 AliITSsegmentation *seg1 =
504 (AliITSsegmentation*)iDetType->GetSegmentationModel();
505 AliITSresponse *res1 = (AliITSresponse*)iDetType->GetResponseModel();
506 TClonesArray *dig1=DigitsAddress(1);
507 TClonesArray *recp1=ClustersAddress(1);
508 AliITSClusterFinderSDD *rec1 =
509 new AliITSClusterFinderSDD(seg1,res1,dig1,recp1);
510 SetReconstructionModel(1,rec1);
511 } // end if
512
513 // SSD
514 iDetType=DetType(2);
515 if (!iDetType->GetReconstructionModel()) {
516 AliITSsegmentation *seg2=
517 (AliITSsegmentation*)iDetType->GetSegmentationModel();
518 TClonesArray *dig2=DigitsAddress(2);
519 AliITSClusterFinderSSD *rec2= new AliITSClusterFinderSSD(seg2,dig2);
520 SetReconstructionModel(2,rec2);
521 } // end if
522}
523//______________________________________________________________________
524void AliITS::MakeBranch(Option_t* option){
525 // Creates Tree branches for the ITS.
526 // Inputs:
527 // Option_t *option String of Tree types S,D, and/or R.
528 // const char *file String of the file name where these branches
529 // are to be stored. If blank then these branches
530 // are written to the same tree as the Hits were
531 // read from.
532 // Outputs:
533 // none.
534 // Return:
535 // none.
536 Bool_t cH = (strstr(option,"H")!=0);
537 Bool_t cS = (strstr(option,"S")!=0);
538 Bool_t cD = (strstr(option,"D")!=0);
539 Bool_t cR = (strstr(option,"R")!=0);
540 Bool_t cRF = (strstr(option,"RF")!=0);
541
542 if(cRF)cR = kFALSE;
543 if(cH && (fHits == 0x0)) fHits = new TClonesArray("AliITShit", 1560);
544
545 AliDetector::MakeBranch(option);
546
547 if(cS) MakeBranchS(0);
548 if(cD) MakeBranchD(0);
549 if(cR) MakeBranchR(0);
550 if(cRF) MakeBranchRF(0);
551}
552//______________________________________________________________________
553void AliITS::SetTreeAddress(){
554 // Set branch address for the Trees.
555 // Inputs:
556 // none.
557 // Outputs:
558 // none.
559 // Return:
560 // none.
561 TTree *treeS = fLoader->TreeS();
562 TTree *treeD = fLoader->TreeD();
563 TTree *treeR = fLoader->TreeR();
564 if (fLoader->TreeH() && (fHits == 0x0)) fHits = new TClonesArray("AliITShit", 1560);
565
566 AliDetector::SetTreeAddress();
567
568 SetTreeAddressS(treeS);
569 SetTreeAddressD(treeD);
570 SetTreeAddressR(treeR);
571}
572//______________________________________________________________________
573AliITSDetType* AliITS::DetType(Int_t id){
574 // Return pointer to id detector type.
575 // Inputs:
576 // Int_t id detector id number.
577 // Outputs:
578 // none.
579 // Return:
580 // returned, a pointer to a AliITSDetType.
581
582 return ((AliITSDetType*) fDetTypes->At(id));
583}
584//______________________________________________________________________
585void AliITS::SetResponseModel(Int_t id, AliITSresponse *response){
586 // Set the response model for the id detector type.
587 // Inputs:
588 // Int_t id detector id number.
589 // AliITSresponse* a pointer containing an instance of AliITSresponse
590 // to be stored/owned b y AliITSDetType.
591 // Outputs:
592 // none.
593 // Return:
594 // none.
595
596 ((AliITSDetType*) fDetTypes->At(id))->ResponseModel(response);
597}
598//______________________________________________________________________
599void AliITS::SetSegmentationModel(Int_t id, AliITSsegmentation *seg){
600 // Set the segmentation model for the id detector type.
601 // Inputs:
602 // Int_t id detector id number.
603 // AliITSsegmentation* a pointer containing an instance of
604 // AliITSsegmentation to be stored/owned b y
605 // AliITSDetType.
606 // Outputs:
607 // none.
608 // Return:
609 // none.
610
611 ((AliITSDetType*) fDetTypes->At(id))->SegmentationModel(seg);
612}
613//______________________________________________________________________
614void AliITS::SetSimulationModel(Int_t id, AliITSsimulation *sim){
615 // Set the simulation model for the id detector type.
616 // Inputs:
617 // Int_t id detector id number.
618 // AliITSresponse* a pointer containing an instance of AliITSresponse
619 // to be stored/owned b y AliITSDetType.
620 // Outputs:
621 // none.
622 // Return:
623 // none.
624
625 ((AliITSDetType*) fDetTypes->At(id))->SimulationModel(sim);
626
627}
628//______________________________________________________________________
629void AliITS::SetReconstructionModel(Int_t id, AliITSClusterFinder *reconst){
630 // Set the cluster finder model for the id detector type.
631 // Inputs:
632 // Int_t id detector id number.
633 // AliITSClusterFinder* a pointer containing an instance of
634 // AliITSClusterFinder to be stored/owned b y
635 // AliITSDetType.
636 // Outputs:
637 // none.
638 // Return:
639 // none.
640
641 ((AliITSDetType*) fDetTypes->At(id))->ReconstructionModel(reconst);
642}
643//______________________________________________________________________
644void AliITS::SetClasses(Int_t id, const char *digit, const char *cluster){
645 // Set the digit and cluster classes name to be used for the id detector
646 // type.
647 // Inputs:
648 // Int_t id detector id number.
649 // const char *digit Digit class name for detector id.
650 // const char *cluster Cluster class name for detector id.
651 // Outputs:
652 // none.
653 // Return:
654 // none.
655
656 ((AliITSDetType*) fDetTypes->At(id))->ClassNames(digit,cluster);
657}
658//______________________________________________________________________
659void AliITS::AddHit(Int_t track, Int_t *vol, Float_t *hits){
660 // Add an ITS hit
661 // The function to add information to the AliITShit class. See the
662 // AliITShit class for a full description. This function allocates the
663 // necessary new space for the hit information and passes the variable
664 // track, and the pointers *vol and *hits to the AliITShit constructor
665 // function.
666 // Inputs:
667 // Int_t track Track number which produced this hit.
668 // Int_t *vol Array of Integer Hit information. See AliITShit.h
669 // Float_t *hits Array of Floating Hit information. see AliITShit.h
670 // Outputs:
671 // none.
672 // Return:
673 // none.
674
675 TClonesArray &lhits = *fHits;
676 new(lhits[fNhits++]) AliITShit(fIshunt,track,vol,hits);
677}
678//______________________________________________________________________
679void AliITS::InitModules(Int_t size,Int_t &nmodules){
680 // Initialize the modules array.
681 // Inputs:
682 // Int_t size Size of array of the number of modules to be
683 // created. If size <=0 then the number of modules
684 // is gotten from AliITSgeom class kept in fITSgeom.
685 // Outputs:
686 // Int_t &nmodules The number of modules existing.
687 // Return:
688 // none.
689
690 if(fITSmodules){
691 fITSmodules->Delete();
692 delete fITSmodules;
693 } // end fir fITSmoudles
694
695 Int_t nl,indexMAX,index;
696
697 if(size<=0){ // default to using data stored in AliITSgeom
698 if(fITSgeom==0) {
699 Error("InitModules","fITSgeom not defined");
700 return;
701 } // end if fITSgeom==0
702 nl = fITSgeom->GetNlayers();
703 indexMAX = fITSgeom->GetModuleIndex(nl,fITSgeom->GetNladders(nl),
704 fITSgeom->GetNdetectors(nl))+1;
705 nmodules = indexMAX;
706 fITSmodules = new TObjArray(indexMAX);
707 for(index=0;index<indexMAX;index++){
708 fITSmodules->AddAt( new AliITSmodule(index),index);
709 } // end for index
710 }else{
711 fITSmodules = new TObjArray(size);
712 for(index=0;index<size;index++) {
713 fITSmodules->AddAt( new AliITSmodule(index),index);
714 } // end for index
715
716 nmodules = size;
717 } // end i size<=0
718}
719//______________________________________________________________________
720void AliITS::FillModules(Int_t evnt,Int_t bgrev,Int_t nmodules,
721 Option_t *option,Text_t *filename){
722 // fill the modules with the sorted by module hits; add hits from
723 // background if option=Add.
724 // Inputs:
725 // Int_t evnt Event to be processed.
726 // Int_t bgrev Background Hit tree number.
727 // Int_t nmodules Not used.
728 // Option_t *option String indicating if merging hits or not. To
729 // merge hits set equal to "Add". Otherwise no
730 // background hits are considered.
731 // Test_t *filename File name containing the background hits..
732 // Outputs:
733 // none.
734 // Return:
735 // none.
736 static TTree *trH1; //Tree with background hits
737 static Bool_t first=kTRUE;
738 static TFile *file;
739 const char *addBgr = strstr(option,"Add");
740
741 evnt = nmodules; // Dummy use of variables to remove warnings
742 if (addBgr ) {
743 if(first) {
744 file=new TFile(filename);
745 } // end if first
746 first=kFALSE;
747 file->cd();
748 file->ls();
749 // Get Hits Tree header from file
750 if(trH1) delete trH1;
751 trH1=0;
752
753 char treeName[20];
754 sprintf(treeName,"TreeH%d",bgrev);
755 trH1 = (TTree*)gDirectory->Get(treeName);
756 if (!trH1) {
757 Error("FillModules","cannot find Hits Tree for event:%d",bgrev);
758 } // end if !trH1
759 // Set branch addresses
760 } // end if addBgr
761
762 FillModules(fLoader->TreeH(),0); // fill from this file's tree.
763
764 if (addBgr ) {
765 FillModules(trH1,10000000); // Default mask 10M.
766 TTree *fAli=fLoader->GetRunLoader()->TreeK();
767 TFile *fileAli=0;
768 if (fAli) fileAli =fAli->GetCurrentFile();
769 fileAli->cd();
770 } // end if add
771}
772//______________________________________________________________________
773void AliITS::FillModules(TTree *treeH, Int_t mask) {
774 // fill the modules with the sorted by module hits;
775 // can be called many times to do a merging
776 // Inputs:
777 // TTree *treeH The tree containing the hits to be copied into
778 // the modules.
779 // Int_t mask The track number mask to indecate which file
780 // this hits came from.
781 // Outputs:
782 // none.
783 // Return:
784 // none.
785
786 if (treeH == 0x0)
787 {
788 Error("FillModules","Tree is NULL");
789 }
790 Int_t lay,lad,det,index;
791 AliITShit *itsHit=0;
792 AliITSmodule *mod=0;
793 char branchname[20];
794 sprintf(branchname,"%s",GetName());
795 TBranch *branch = treeH->GetBranch(branchname);
796 if (!branch) {
797 Error("FillModules","%s branch in TreeH not found",branchname);
798 return;
799 } // end if !branch
800 branch->SetAddress(&fHits);
801 Int_t nTracks =(Int_t) treeH->GetEntries();
802 Int_t iPrimTrack,h;
803 for(iPrimTrack=0; iPrimTrack<nTracks; iPrimTrack++){
804 ResetHits();
805 Int_t nBytes = treeH->GetEvent(iPrimTrack);
806 if (nBytes <= 0) continue;
807 Int_t nHits = fHits->GetEntriesFast();
808 for(h=0; h<nHits; h++){
809 itsHit = (AliITShit *)fHits->UncheckedAt(h);
810 itsHit->GetDetectorID(lay,lad,det);
811 if (fITSgeom) {
812 index = fITSgeom->GetModuleIndex(lay,lad,det);
813 } else {
814 index=det-1; // This should not be used.
815 } // end if [You must have fITSgeom for this to work!]
816 mod = GetModule(index);
817 itsHit->SetTrack(itsHit->GetTrack()+mask); // Set track mask.
818 mod->AddHit(itsHit,iPrimTrack,h);
819 } // end loop over hits
820 } // end loop over tracks
821}
822//______________________________________________________________________
823void AliITS::ClearModules(){
824 // Clear the modules TObjArray.
825 // Inputs:
826 // none.
827 // Outputs:
828 // none.
829
830 if(fITSmodules) fITSmodules->Delete();
831}
832//______________________________________________________________________
833void AliITS::MakeBranchS(const char *fl){
834 // Creates Tree Branch for the ITS summable digits.
835 // Inputs:
836 // cont char *fl File name where SDigits branch is to be written
837 // to. If blank it write the SDigits to the same
838 // file in which the Hits were found.
839 // Outputs:
840 // none.
841 // Return:
842 // none.
843 Int_t buffersize = 4000;
844 char branchname[30];
845
846 // only one branch for SDigits.
847 sprintf(branchname,"%s",GetName());
848
849
850 if(fLoader->TreeS()){
851 if (fSDigits == 0x0) fSDigits = new TClonesArray("AliITSpListItem",1000);
852 MakeBranchInTree(fLoader->TreeS(),branchname,&fSDigits,buffersize,fl);
853 } // end if
854}
855//______________________________________________________________________
856void AliITS::SetTreeAddressS(TTree *treeS){
857 // Set branch address for the ITS summable digits Trees.
858 // Inputs:
859 // TTree *treeS Tree containing the SDigits.
860 // Outputs:
861 // none.
862 // Return:
863 // none.
864 char branchname[30];
865
866 if(!treeS) return;
867 if (fSDigits == 0x0) fSDigits = new TClonesArray("AliITSpListItem",1000);
868 TBranch *branch;
869 sprintf(branchname,"%s",GetName());
870 branch = treeS->GetBranch(branchname);
871 if (branch) branch->SetAddress(&fSDigits);
872}
873//______________________________________________________________________
874void AliITS::MakeBranchInTreeD(TTree *treeD,const char *file){
875 // Creates Tree branches for the ITS.
876 // Inputs:
877 // TTree *treeD Pointer to the Digits Tree.
878 // cont char *file File name where Digits branch is to be written
879 // to. If blank it write the SDigits to the same
880 // file in which the Hits were found.
881 // Outputs:
882 // none.
883 // Return:
884 // none.
885 Int_t buffersize = 4000;
886 char branchname[30];
887
888 sprintf(branchname,"%s",GetName());
889 // one branch for digits per type of detector
890 const char *det[3] = {"SPD","SDD","SSD"};
891 char digclass[40];
892 char clclass[40];
893 Int_t i;
894 for (i=0; i<kNTYPES ;i++) {
895 DetType(i)->GetClassNames(digclass,clclass);
896 // digits
897 if (fDtype == 0x0) fDtype = new TObjArray(fNDetTypes);
898 if(!(fDtype->At(i))) fDtype->AddAt(new TClonesArray(digclass,1000),i);
899 else ResetDigits(i);
900 } // end for i
901 for (i=0; i<kNTYPES ;i++) {
902 if (kNTYPES==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
903 else sprintf(branchname,"%sDigits%d",GetName(),i+1);
904 if (fDtype && treeD) {
905 MakeBranchInTree(treeD, branchname, &((*fDtype)[i]),buffersize,file);
906 } // end if
907 } // end for i
908}
909//______________________________________________________________________
910void AliITS::SetTreeAddressD(TTree *treeD){
911 // Set branch address for the Trees.
912 // Inputs:
913 // TTree *treeD Tree containing the Digits.
914 // Outputs:
915 // none.
916 // Return:
917 // none.
918 char branchname[30];
919 const char *det[3] = {"SPD","SDD","SSD"};
920 TBranch *branch;
921 char digclass[40];
922 char clclass[40];
923 Int_t i;
924
925 if(!treeD) return;
926 for (i=0; i<kNTYPES; i++) {
927 DetType(i)->GetClassNames(digclass,clclass);
928 // digits
929 if (fDtype == 0x0) fDtype = new TObjArray(fNDetTypes);
930 if(!(fDtype->At(i))) fDtype->AddAt(new TClonesArray(digclass,1000),i);
931 else ResetDigits(i);
932 if (kNTYPES==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
933 else sprintf(branchname,"%sDigits%d",GetName(),i+1);
934 if (fDtype) {
935 branch = treeD->GetBranch(branchname);
936 if (branch) branch->SetAddress(&((*fDtype)[i]));
937 } // end if fDtype
938 } // end for i
939}
940//______________________________________________________________________
941void AliITS::Hits2SDigits(){
942 // Standard Hits to summable Digits function.
943 // Inputs:
944 // none.
945 // Outputs:
946 // none.
947
948// return; // Using Hits in place of the larger sDigits.
949 AliRunLoader* rl = fLoader->GetRunLoader();
950 AliHeader *header=rl->GetHeader(); // Get event number from this file.
951 if (header == 0x0)
952 {
953 rl->LoadHeader();
954 header=rl->GetHeader();
955 if (header == 0x0) return;
956 }
957 // Do the Hits to Digits operation. Use Standard input values.
958 // Event number from file, no background hit merging , use size from
959 // AliITSgeom class, option="All", input from this file only.
960 HitsToSDigits(header->GetEvent(),0,-1," ",fOpt," ");
961
962}
963//______________________________________________________________________
964void AliITS::Hits2PreDigits(){
965 // Standard Hits to summable Digits function.
966 // Inputs:
967 // none.
968 // Outputs:
969 // none.
970
971 AliHeader *header=fLoader->GetRunLoader()->GetHeader(); // Get event number from this file.
972 // Do the Hits to Digits operation. Use Standard input values.
973 // Event number from file, no background hit merging , use size from
974 // AliITSgeom class, option="All", input from this file only.
975 HitsToPreDigits(header->GetEvent(),0,-1," ",fOpt," ");
976}
977//______________________________________________________________________
978void AliITS::SDigitsToDigits(Option_t *opt){
979 // Standard Summable digits to Digits function.
980 // Inputs:
981 // none.
982 // Outputs:
983 // none.
984 char name[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
985
986 if(!GetITSgeom()) return; // need transformations to do digitization.
987 AliITSgeom *geom = GetITSgeom();
988
989 const char *all = strstr(opt,"All");
990 const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
991 strstr(opt,"SSD")};
992 if( !det[0] && !det[1] && !det[2] ) all = "All";
993 else all = 0;
994 static Bool_t setDef=kTRUE;
995 if (setDef) SetDefaultSimulation();
996 setDef=kFALSE;
997
998 AliITSsimulation *sim = 0;
999 AliITSDetType *iDetType = 0;
1000 TTree *trees = fLoader->TreeS();
1001 if( !(trees && this->GetSDigits()) ){
1002 Error("SDigits2Digits","Error: No trees or SDigits. Returning.");
1003 return;
1004 } // end if
1005 sprintf( name, "%s", this->GetName() );
1006 TBranch *brchSDigits = trees->GetBranch( name );
1007
1008 Int_t id,module;
1009 for(module=0;module<geom->GetIndexMax();module++){
1010 id = geom->GetModuleType(module);
1011 if (!all && !det[id]) continue;
1012 iDetType = DetType(id);
1013 sim = (AliITSsimulation*)iDetType->GetSimulationModel();
1014 if (!sim) {
1015 Error("SDigit2Digits",
1016 "The simulation class was not instanciated!");
1017 exit(1);
1018 } // end if !sim
1019 sim->InitSimulationModule(module,gAlice->GetEvNumber());
1020//
1021 // add summable digits to module
1022 this->GetSDigits()->Clear();
1023 brchSDigits->GetEvent(module);
1024 sim->AddSDigitsToModule(GetSDigits(),0);
1025//
1026 // Digitise current module sum(SDigits)->Digits
1027 sim->FinishSDigitiseModule();
1028
1029 // fills all branches - wasted disk space
1030 fLoader->TreeD()->Fill();
1031 this->ResetDigits();
1032 } // end for module
1033
1034 fLoader->TreeD()->GetEntries();
1035
1036 fLoader->TreeD()->AutoSave();
1037 // reset tree
1038 fLoader->TreeD()->Reset();
1039
1040}
1041//______________________________________________________________________
1042void AliITS::Hits2Digits(){
1043 // Standard Hits to Digits function.
1044 // Inputs:
1045 // none.
1046 // Outputs:
1047 // none.
1048
1049 AliHeader *header=fLoader->GetRunLoader()->GetHeader(); // Get event number from this file.
1050 // Do the Hits to Digits operation. Use Standard input values.
1051 // Event number from file, no background hit merging , use size from
1052 // AliITSgeom class, option="All", input from this file only.
1053 HitsToDigits(header->GetEvent(),0,-1," ",fOpt," ");
1054}
1055//______________________________________________________________________
1056void AliITS::HitsToSDigits(Int_t evNumber,Int_t bgrev,Int_t size,
1057 Option_t *option, Option_t *opt,Text_t *filename){
1058 // keep galice.root for signal and name differently the file for
1059 // background when add! otherwise the track info for signal will be lost !
1060 // the condition below will disappear when the geom class will be
1061 // initialized for all versions - for the moment it is only for v5 !
1062 // 7 is the SDD beam test version. Dummy routine. Hits are ITS's Summable
1063 // Digits.
1064 // Inputs:
1065 // Int_t evnt Event to be processed.
1066 // Int_t bgrev Background Hit tree number.
1067 // Int_t nmodules Not used.
1068 // Option_t *option String indicating if merging hits or not. To
1069 // merge hits set equal to "Add". Otherwise no
1070 // background hits are considered.
1071 // Test_t *filename File name containing the background hits..
1072 // Outputs:
1073 // none.
1074 // Return:
1075 // none.
1076// return; // using Hits instead of the larger sdigits.
1077
1078 HitsToPreDigits(evNumber,bgrev,size,option,opt,filename);
1079}
1080//______________________________________________________________________
1081void AliITS::HitsToPreDigits(Int_t evNumber,Int_t bgrev,Int_t size,
1082 Option_t *option, Option_t *opt,Text_t *filename){
1083 // Keep galice.root for signal and name differently the file for
1084 // background when add! otherwise the track info for signal will be lost !
1085 // the condition below will disappear when the geom class will be
1086 // initialized for all versions - for the moment it is only for v5 !
1087 // 7 is the SDD beam test version.
1088 // Inputs:
1089 // Int_t evnt Event to be processed.
1090 // Int_t bgrev Background Hit tree number.
1091 // Int_t nmodules Not used.
1092 // Option_t *option String indicating if merging hits or not. To
1093 // merge hits set equal to "Add". Otherwise no
1094 // background hits are considered.
1095 // Test_t *filename File name containing the background hits..
1096 // Outputs:
1097 // none.
1098 // Return:
1099 // none.
1100
1101 if(!GetITSgeom()) return; // need transformations to do digitization.
1102 AliITSgeom *geom = GetITSgeom();
1103
1104 const char *all = strstr(opt,"All");
1105 const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
1106 strstr(opt,"SSD")};
1107 static Bool_t setDef=kTRUE;
1108 if (setDef) SetDefaultSimulation();
1109 setDef=kFALSE;
1110
1111 Int_t nmodules;
1112 InitModules(size,nmodules);
1113 FillModules(evNumber,bgrev,nmodules,option,filename);
1114
1115 AliITSsimulation *sim = 0;
1116 AliITSDetType *iDetType = 0;
1117 AliITSmodule *mod = 0;
1118 Int_t id,module;
1119 for(module=0;module<geom->GetIndexMax();module++){
1120 id = geom->GetModuleType(module);
1121 if (!all && !det[id]) continue;
1122 iDetType = DetType(id);
1123 sim = (AliITSsimulation*)iDetType->GetSimulationModel();
1124 if (!sim) {
1125 Error("HitsToSDigits",
1126 "The simulation class was not instanciated!");
1127 exit(1);
1128 } // end if !sim
1129 mod = (AliITSmodule *)fITSmodules->At(module);
1130 sim->SDigitiseModule(mod,module,evNumber);
1131 // fills all branches - wasted disk space
1132 fLoader->TreeS()->Fill();
1133 ResetSDigits();
1134 } // end for module
1135
1136 ClearModules();
1137
1138 fLoader->TreeS()->GetEntries();
1139 fLoader->TreeS()->AutoSave();
1140 fLoader->WriteSDigits("OVERWRITE");
1141 // reset tree
1142 fLoader->TreeS()->Reset();
1143}
1144//______________________________________________________________________
1145void AliITS::HitsToDigits(Int_t evNumber,Int_t bgrev,Int_t size,
1146 Option_t *option, Option_t *opt,Text_t *filename){
1147 // Keep galice.root for signal and name differently the file for
1148 // background when add! otherwise the track info for signal will be lost !
1149 // the condition below will disappear when the geom class will be
1150 // initialized for all versions - for the moment it is only for v5 !
1151 // 7 is the SDD beam test version.
1152 // Inputs:
1153 // Int_t evnt Event to be processed.
1154 // Int_t bgrev Background Hit tree number.
1155 // Int_t nmodules Not used.
1156 // Option_t *option String indicating if merging hits or not. To
1157 // merge hits set equal to "Add". Otherwise no
1158 // background hits are considered.
1159 // Test_t *filename File name containing the background hits..
1160 // Outputs:
1161 // none.
1162 // Return:
1163 // none.
1164
1165 if(!GetITSgeom()) return; // need transformations to do digitization.
1166 AliITSgeom *geom = GetITSgeom();
1167
1168 const char *all = strstr(opt,"All");
1169 const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
1170 strstr(opt,"SSD")};
1171 static Bool_t setDef=kTRUE;
1172 if (setDef) SetDefaultSimulation();
1173 setDef=kFALSE;
1174
1175 Int_t nmodules;
1176 InitModules(size,nmodules);
1177 FillModules(evNumber,bgrev,nmodules,option,filename);
1178
1179 AliITSsimulation *sim = 0;
1180 AliITSDetType *iDetType = 0;
1181 AliITSmodule *mod = 0;
1182 Int_t id,module;
1183 for(module=0;module<geom->GetIndexMax();module++){
1184 id = geom->GetModuleType(module);
1185 if (!all && !det[id]) continue;
1186 iDetType = DetType(id);
1187 sim = (AliITSsimulation*)iDetType->GetSimulationModel();
1188 if (!sim) {
1189 Error("HitsToDigits",
1190 "The simulation class was not instanciated!");
1191 exit(1);
1192 } // end if !sim
1193 mod = (AliITSmodule *)fITSmodules->At(module);
1194 sim->DigitiseModule(mod,module,evNumber);
1195 // fills all branches - wasted disk space
1196 fLoader->TreeD()->Fill();
1197 ResetDigits();
1198 } // end for module
1199
1200 ClearModules();
1201
1202 fLoader->TreeD()->GetEntries();
1203 fLoader->TreeD()->AutoSave();
1204 // reset tree
1205 fLoader->TreeD()->Reset();
1206}
1207//______________________________________________________________________
1208void AliITS::ResetSDigits(){
1209 // Reset the Summable Digits array.
1210 // Inputs:
1211 // none.
1212 // Outputs:
1213 // none.
1214
1215 if (fSDigits) fSDigits->Clear();
1216 fNSDigits = 0;
1217}
1218//______________________________________________________________________
1219void AliITS::ResetDigits(){
1220 // Reset number of digits and the digits array for the ITS detector.
1221 // Inputs:
1222 // none.
1223 // Outputs:
1224 // none.
1225
1226 if (!fDtype) return;
1227
1228 Int_t i;
1229 for (i=0;i<kNTYPES;i++ ) {
1230 if (fDtype->At(i)) ((TClonesArray*)fDtype->At(i))->Clear();
1231 if (fNdtype) fNdtype[i]=0;
1232 } // end for i
1233}
1234//______________________________________________________________________
1235void AliITS::ResetDigits(Int_t i){
1236 // Reset number of digits and the digits array for this branch.
1237 // Inputs:
1238 // none.
1239 // Outputs:
1240 // none.
1241
1242 if (fDtype->At(i)) ((TClonesArray*)fDtype->At(i))->Clear();
1243 if (fNdtype) fNdtype[i]=0;
1244}
1245//______________________________________________________________________
1246void AliITS::AddSumDigit(AliITSpListItem &sdig){
1247 // Adds the a module full of summable digits to the summable digits tree.
1248 // Inputs:
1249 // AliITSpListItem &sdig SDigit to be added to SDigits tree.
1250 // Outputs:
1251 // none.
1252 // Return:
1253 // none.
1254
1255 TClonesArray &lsdig = *fSDigits;
1256 new(lsdig[fNSDigits++]) AliITSpListItem(sdig);
1257}
1258//______________________________________________________________________
1259void AliITS::AddRealDigit(Int_t id, Int_t *digits){
1260 // Add a real digit - as coming from data.
1261 // Inputs:
1262 // Int_t id Detector type number.
1263 // Int_t *digits Integer array containing the digits info. See
1264 // AliITSdigit.h
1265 // Outputs:
1266 // none.
1267 // Return:
1268 // none.
1269
1270 TClonesArray &ldigits = *((TClonesArray*)fDtype->At(id));
1271 new(ldigits[fNdtype[id]++]) AliITSdigit(digits);
1272}
1273//______________________________________________________________________
1274void AliITS::AddSimDigit(Int_t id, AliITSdigit *d){
1275 // Add a simulated digit.
1276 // Inputs:
1277 // Int_t id Detector type number.
1278 // AliITSdigit *d Digit to be added to the Digits Tree. See
1279 // AliITSdigit.h
1280 // Outputs:
1281 // none.
1282 // Return:
1283 // none.
1284
1285 TClonesArray &ldigits = *((TClonesArray*)fDtype->At(id));
1286
1287 switch(id){
1288 case 0:
1289 new(ldigits[fNdtype[id]++]) AliITSdigitSPD(*((AliITSdigitSPD*)d));
1290 break;
1291 case 1:
1292 new(ldigits[fNdtype[id]++]) AliITSdigitSDD(*((AliITSdigitSDD*)d));
1293 break;
1294 case 2:
1295 new(ldigits[fNdtype[id]++]) AliITSdigitSSD(*((AliITSdigitSSD*)d));
1296 break;
1297 } // end switch id
1298}
1299//______________________________________________________________________
1300void AliITS::AddSimDigit(Int_t id,Float_t phys,Int_t *digits,Int_t *tracks,
1301 Int_t *hits,Float_t *charges){
1302 // Add a simulated digit to the list.
1303 // Inputs:
1304 // Int_t id Detector type number.
1305 // Float_t phys Physics indicator. See AliITSdigits.h
1306 // Int_t *digits Integer array containing the digits info. See
1307 // AliITSdigit.h
1308 // Int_t *tracks Integer array [AliITSdigitS?D::GetNTracks()]
1309 // containing the track numbers that contributed to
1310 // this digit.
1311 // Int_t *hits Integer array [AliITSdigitS?D::GetNTracks()]
1312 // containing the hit numbers, from AliITSmodule, that
1313 // contributed to this digit.
1314 // Float_t *charge Floating point array of the signals contributed
1315 // to this digit by each track.
1316 // Outputs:
1317 // none.
1318 // Return:
1319 // none.
1320
1321 TClonesArray &ldigits = *((TClonesArray*)fDtype->At(id));
1322 switch(id){
1323 case 0:
1324 new(ldigits[fNdtype[id]++]) AliITSdigitSPD(digits,tracks,hits);
1325 break;
1326 case 1:
1327 new(ldigits[fNdtype[id]++]) AliITSdigitSDD(phys,digits,tracks,
1328 hits,charges);
1329 break;
1330 case 2:
1331 new(ldigits[fNdtype[id]++]) AliITSdigitSSD(digits,tracks,hits);
1332 break;
1333 } // end switch id
1334}
1335//______________________________________________________________________
1336void AliITS::MakeTreeC(Option_t *option){
1337 // Create a separate tree to store the clusters.
1338 // Inputs:
1339 // Option_t *option string which must contain "C" otherwise
1340 // no Cluster Tree is created.
1341 // Outputs:
1342 // none.
1343 // Return:
1344 // none.
1345
1346 AliITSLoader *pITSLoader = (AliITSLoader*)fLoader;
1347
1348 if (pITSLoader == 0x0) {
1349 Error("MakeTreeC","fLoader == 0x0 option=%s",option);
1350 return;
1351 }
1352 if (pITSLoader->TreeC() == 0x0) pITSLoader->MakeTree("C");
1353 MakeBranchC();
1354}
1355
1356void AliITS::MakeBranchC()
1357{
1358//Makes barnches in treeC
1359 AliITSLoader *pITSLoader = (AliITSLoader*)fLoader;
1360 if (pITSLoader == 0x0)
1361 {
1362 Error("MakeTreeC","fLoader == 0x0");
1363 return;
1364 }
1365 TTree * lTC = pITSLoader->TreeC();
1366 if (lTC == 0x0)
1367 {
1368 Error("MakeTreeC","Can not get TreeC from Loader");
1369 return;
1370 }
1371
1372 Int_t buffersize = 4000;
1373 char branchname[30];
1374 const char *det[3] = {"SPD","SDD","SSD"};
1375 char digclass[40];
1376 char clclass[40];
1377
1378 // one branch for Clusters per type of detector
1379 Int_t i;
1380 for (i=0; i<kNTYPES ;i++)
1381 {
1382 AliITSDetType *iDetType=DetType(i);
1383 iDetType->GetClassNames(digclass,clclass);
1384 // clusters
1385 if (fCtype == 0x0) fCtype = new TObjArray(fNDetTypes);
1386 if(!ClustersAddress(i))
1387 {
1388 fCtype->AddAt(new TClonesArray(clclass,1000),i);
1389 }
1390 if (kNTYPES==3) sprintf(branchname,"%sClusters%s",GetName(),det[i]);
1391 else sprintf(branchname,"%sClusters%d",GetName(),i+1);
1392 if (fCtype && lTC)
1393 {
1394 if (lTC->GetBranch(branchname))
1395 {
1396 Warning("MakeBranchC","Branch %s alread exists in TreeC",branchname);
1397 }
1398 else
1399 {
1400 Info("MakeBranchC","Creating branch %s in TreeC",branchname);
1401 lTC->Branch(branchname,&((*fCtype)[i]), buffersize);
1402 }
1403 } // end if fCtype && lTC
1404 } // end for i
1405}
1406
1407//______________________________________________________________________
1408void AliITS::GetTreeC(Int_t event){
1409 // Get the clusters tree for this event and set the branch address.
1410 // Inputs:
1411 // Int_t event Event number for the cluster tree.
1412 // Outputs:
1413 // none.
1414 // Return:
1415 // none.
1416 char branchname[30];
1417 const char *det[3] = {"SPD","SDD","SSD"};
1418
1419 AliITSLoader *pITSLoader = (AliITSLoader*)fLoader;
1420 TTree * lTC = pITSLoader->TreeC();
1421
1422 ResetClusters();
1423 if (lTC) {
1424 pITSLoader->CleanRawClusters();
1425 } // end if TreeC()
1426
1427
1428 TBranch *branch;
1429
1430 if (lTC) {
1431 Int_t i;
1432 char digclass[40];
1433 char clclass[40];
1434 for (i=0; i<kNTYPES; i++) {
1435 AliITSDetType *iDetType=DetType(i);
1436 iDetType->GetClassNames(digclass,clclass);
1437 // clusters
1438 if (fCtype == 0x0) fCtype = new TObjArray(fNDetTypes);
1439 if(!fCtype->At(i)) fCtype->AddAt(new TClonesArray(clclass,1000),i);
1440 if(kNTYPES==3) sprintf(branchname,"%sClusters%s",GetName(),det[i]);
1441 else sprintf(branchname,"%sClusters%d",GetName(),i+1);
1442 if (fCtype) {
1443 branch = lTC->GetBranch(branchname);
1444 if (branch) branch->SetAddress(&((*fCtype)[i]));
1445 } // end if fCtype
1446 } // end for i
1447 } else {
1448 Error("GetTreeC","cannot find Clusters Tree for event:%d",event);
1449 } // end if lTC
1450}
1451//______________________________________________________________________
1452void AliITS::AddCluster(Int_t id, AliITSRawCluster *c){
1453 // Add a cluster to the list.
1454 // Inputs:
1455 // Int_t id Detector type number.
1456 // AliITSRawCluster *c Cluster class to be added to the tree of
1457 // clusters.
1458 // Outputs:
1459 // none.
1460 // Return:
1461 // none.
1462
1463 TClonesArray &lc = *((TClonesArray*)fCtype->At(id));
1464
1465 switch(id){
1466 case 0:
1467 new(lc[fNctype[id]++]) AliITSRawClusterSPD(*((AliITSRawClusterSPD*)c));
1468 break;
1469 case 1:
1470 new(lc[fNctype[id]++]) AliITSRawClusterSDD(*((AliITSRawClusterSDD*)c));
1471 break;
1472 case 2:
1473 new(lc[fNctype[id]++]) AliITSRawClusterSSD(*((AliITSRawClusterSSD*)c));
1474 break;
1475 } // end switch id
1476}
1477//______________________________________________________________________
1478void AliITS::ResetClusters(){
1479 // Reset number of clusters and the clusters array for ITS.
1480 // Inputs:
1481 // none.
1482 // Outputs:
1483 // none.
1484
1485 Int_t i;
1486 for (i=0;i<kNTYPES;i++ ) ResetClusters(i);
1487}
1488//______________________________________________________________________
1489void AliITS::ResetClusters(Int_t i){
1490 // Reset number of clusters and the clusters array for this branch.
1491 // Inputs:
1492 // Int_t i Detector type number.
1493 // Outputs:
1494 // none.
1495 // Return:
1496 // none.
1497
1498 if (fCtype->At(i)) ((TClonesArray*)fCtype->At(i))->Clear();
1499 if (fNctype) fNctype[i]=0;
1500}
1501//______________________________________________________________________
1502void AliITS::MakeBranchR(const char *file, Option_t *opt){
1503 // Creates Tree branches for the ITS Reconstructed points.
1504 // Inputs:
1505 // cont char *file File name where RecPoints branch is to be written
1506 // to. If blank it write the SDigits to the same
1507 // file in which the Hits were found.
1508 // Outputs:
1509 // none.
1510 // Return:
1511 // none.
1512 Int_t buffsz = 4000;
1513 char branchname[30];
1514
1515 // only one branch for rec points for all detector types
1516 Bool_t oFast= (strstr(opt,"Fast")!=0);
1517 if(oFast){
1518 sprintf(branchname,"%sRecPointsF",GetName());
1519 } else {
1520 sprintf(branchname,"%sRecPoints",GetName());
1521 }
1522
1523
1524 if(!fRecPoints)fRecPoints = new TClonesArray("AliITSRecPoint",1000);
1525 if (fLoader->TreeR()) {
1526 if (fRecPoints == 0x0) fRecPoints = new TClonesArray("AliITSRecPoint",1000);
1527 MakeBranchInTree(fLoader->TreeR(),branchname,&fRecPoints,buffsz,file);
1528 } // end if
1529}
1530//______________________________________________________________________
1531void AliITS::SetTreeAddressR(TTree *treeR){
1532 // Set branch address for the Reconstructed points Trees.
1533 // Inputs:
1534 // TTree *treeR Tree containing the RecPoints.
1535 // Outputs:
1536 // none.
1537 // Return:
1538 // none.
1539 char branchname[30];
1540
1541 if(!treeR) return;
1542 if (fRecPoints == 0x0) fRecPoints = new TClonesArray("AliITSRecPoint",1000);
1543 TBranch *branch;
1544 sprintf(branchname,"%sRecPoints",GetName());
1545 branch = treeR->GetBranch(branchname);
1546 if (branch) {
1547 branch->SetAddress(&fRecPoints);
1548 }
1549 else {
1550 sprintf(branchname,"%sRecPointsF",GetName());
1551 branch = treeR->GetBranch(branchname);
1552 if (branch) {
1553 branch->SetAddress(&fRecPoints);
1554 }
1555 }
1556}
1557//______________________________________________________________________
1558void AliITS::AddRecPoint(const AliITSRecPoint &r){
1559 // Add a reconstructed space point to the list
1560 // Inputs:
1561 // const AliITSRecPoint &r RecPoint class to be added to the tree
1562 // of reconstructed points TreeR.
1563 // Outputs:
1564 // none.
1565 // Return:
1566 // none.
1567
1568 TClonesArray &lrecp = *fRecPoints;
1569 new(lrecp[fNRecPoints++]) AliITSRecPoint(r);
1570}
1571//______________________________________________________________________
1572void AliITS::HitsToFastRecPoints(Int_t evNumber,Int_t bgrev,Int_t size,
1573 Option_t *opt0,Option_t *opt1,Text_t *flnm){
1574 // keep galice.root for signal and name differently the file for
1575 // background when add! otherwise the track info for signal will be lost !
1576 // the condition below will disappear when the geom class will be
1577 // initialized for all versions - for the moment it is only for v5 !
1578 // Inputs:
1579 // Int_t evnt Event to be processed.
1580 // Int_t bgrev Background Hit tree number.
1581 // Int_t size Size used by InitModules. See InitModules.
1582 // Option_t *opt0 Option passed to FillModules. See FillModules.
1583 // Option_t *opt1 String indicating if merging hits or not. To
1584 // merge hits set equal to "Add". Otherwise no
1585 // background hits are considered.
1586 // Test_t *flnm File name containing the background hits..
1587 // Outputs:
1588 // none.
1589 // Return:
1590 // none.
1591
1592 if(!GetITSgeom()) return;
1593 AliITSLoader *pITSloader = (AliITSLoader*)fLoader;
1594 AliITSgeom *geom = GetITSgeom();
1595
1596 const char *all = strstr(opt1,"All");
1597 const char *det[3] ={strstr(opt1,"SPD"),strstr(opt1,"SDD"),
1598 strstr(opt1,"SSD")};
1599 Int_t nmodules;
1600 InitModules(size,nmodules);
1601 FillModules(evNumber,bgrev,nmodules,opt0,flnm);
1602
1603 AliITSsimulation *sim = 0;
1604 AliITSDetType *iDetType = 0;
1605 AliITSmodule *mod = 0;
1606 Int_t id,module;
1607
1608 //m.b. : this change is nothing but a nice way to make sure
1609 //the CPU goes up !
1610
1611 cout<<"HitsToFastRecPoints: N mod = "<<geom->GetIndexMax()<<endl;
1612
1613 for(module=0;module<geom->GetIndexMax();module++)
1614 {
1615 id = geom->GetModuleType(module);
1616 if (!all && !det[id]) continue;
1617 iDetType = DetType(id);
1618 sim = (AliITSsimulation*)iDetType->GetSimulationModel();
1619 if (!sim)
1620 {
1621 Error("HitsToFastPoints","The simulation class was not instanciated!");
1622 exit(1);
1623 } // end if !sim
1624 mod = (AliITSmodule *)fITSmodules->At(module);
1625 sim->CreateFastRecPoints(mod,module,gRandom);
1626 cout<<module<<"\r";fflush(0);
1627 //gAlice->TreeR()->Fill();
1628 TTree *lTR = pITSloader->TreeR();
1629 TBranch *br=lTR->GetBranch("ITSRecPointsF");
1630 br->Fill();
1631 ResetRecPoints();
1632 } // end for module
1633
1634 ClearModules();
1635
1636 fLoader->WriteRecPoints("OVERWRITE");
1637}
1638//______________________________________________________________________
1639void AliITS::Digits2Reco(){
1640 // Find clusters and reconstruct space points.
1641 // Inputs:
1642 // none.
1643 // Outputs:
1644 // none.
1645
1646 AliHeader *header=fLoader->GetRunLoader()->GetHeader();
1647 // to Digits to RecPoints for event in file, all digits in file, and
1648 // all ITS detectors.
1649 DigitsToRecPoints(header->GetEvent(),0,fOpt);
1650}
1651//______________________________________________________________________
1652void AliITS::DigitsToRecPoints(Int_t evNumber,Int_t lastentry,Option_t *opt){
1653 // cluster finding and reconstruction of space points
1654 // the condition below will disappear when the geom class will be
1655 // initialized for all versions - for the moment it is only for v5 !
1656 // 7 is the SDD beam test version
1657 // Inputs:
1658 // Int_t evNumber Event number to be processed.
1659 // Int_t lastentry Offset for module when not all of the modules
1660 // are processed.
1661 // Option_t *opt String indicating which ITS sub-detectors should
1662 // be processed. If ="All" then all of the ITS
1663 // sub detectors are processed.
1664 // Outputs:
1665 // none.
1666 // Return:
1667 // none.
1668
1669 if(!GetITSgeom()) return;
1670 AliITSgeom *geom = GetITSgeom();
1671
1672 const char *all = strstr(opt,"All");
1673 const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
1674 strstr(opt,"SSD")};
1675 static Bool_t setRec=kTRUE;
1676 if (setRec) SetDefaultClusterFinders();
1677 setRec=kFALSE;
1678
1679 AliITSLoader *pITSloader = (AliITSLoader*)fLoader;
1680 TTree *treeC=pITSloader->TreeC();
1681 AliITSClusterFinder *rec = 0;
1682 AliITSDetType *iDetType = 0;
1683 Int_t id,module,first=0;
1684 for(module=0;module<geom->GetIndexMax();module++){
1685 id = geom->GetModuleType(module);
1686 if (!all && !det[id]) continue;
1687 if(det[id]) first = geom->GetStartDet(id);
1688 iDetType = DetType(id);
1689 rec = (AliITSClusterFinder*)iDetType->GetReconstructionModel();
1690 TClonesArray *itsDigits = this->DigitsAddress(id);
1691 if (!rec) {
1692 Error("DigitsToRecPoints",
1693 "The reconstruction class was not instanciated! event=%d",
1694 evNumber);
1695 exit(1);
1696 } // end if !rec
1697 this->ResetDigits();
1698 TTree *lTD = pITSloader->TreeD();
1699 if (all) {
1700 lTD->GetEvent(lastentry+module);
1701 }else {
1702 lTD->GetEvent(lastentry+(module-first));
1703 }
1704 Int_t ndigits = itsDigits->GetEntriesFast();
1705 if (ndigits) rec->FindRawClusters(module);
1706 pITSloader->TreeR()->Fill();
1707 ResetRecPoints();
1708 treeC->Fill();
1709 ResetClusters();
1710 } // end for module
1711
1712
1713 pITSloader->WriteRecPoints("OVERWRITE");
1714 pITSloader->WriteRawClusters("OVERWRITE");
1715}
1716//______________________________________________________________________
1717void AliITS::ResetRecPoints(){
1718 // Reset number of rec points and the rec points array.
1719 // Inputs:
1720 // none.
1721 // Outputs:
1722 // none.
1723
1724 if (fRecPoints) fRecPoints->Clear();
1725 fNRecPoints = 0;
1726}
1727//______________________________________________________________________
1728AliLoader* AliITS::MakeLoader(const char* topfoldername)
1729{
1730 //builds ITSgetter (AliLoader type)
1731 //if detector wants to use castomized getter, it must overload this method
1732
1733 Info("MakeLoader","Creating AliITSLoader. Top folder is %s.",topfoldername);
1734 fLoader = new AliITSLoader(GetName(),topfoldername);
1735 return fLoader;
1736}
1737
1738