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