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