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