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