ITS/AliITS.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /*
  17 $Log$
  18 Revision 1.14  2000/06/15 09:27:52  barbera
  19 Problems with the HP compiler fixed
  20
  21 Revision 1.13  2000/06/13 15:32:44  nilsen
  22 fix compilation error on HP and DEC unix.
  23
  24 Revision 1.12  2000/06/12 23:43:16  nilsen
  25 New ITS code replacing the old structure and simulations code.
  26
  27 Revision 1.9.2.8  2000/06/12 18:05:59  barbera
  28 fixed posible compilation errors on HP unix
  29
  30 Revision 1.9.2.7  2000/06/11 20:20:18  barbera
  31 New AliITS base clase  for the new structure.
  32
  33 Revision 1.9.2.3  2000/02/02 13:42:09  barbera
  34 fixed AliITS.cxx for new AliRun structure. Added ITS hits list to list of hits which will have their track numbers updated
  35
  36 Revision 1.9.2.2  2000/01/23 03:03:13  nilsen
  37 //fixed FillModule. Removed fi(fabs(xl)<dx....
  38
  39 Revision 1.9.2.1  2000/01/12 19:03:32  nilsen
  40 This is the version of the files after the merging done in December 1999.
  41 See the ReadMe110100.txt file for details
  42
  43 Revision 1.9  1999/11/14 14:33:25  fca
  44 Correct problems with distructors and pointers, thanks to I.Hrivnacova
  45
  46 Revision 1.8  1999/09/29 09:24:19  fca
  47 Introduction of the Copyright and cvs Log
  48
  49 */
  50
  51 ///////////////////////////////////////////////////////////////////////////////
  52 //
  53 //      An overview of the basic philosophy of the ITS code development
  54 // and analysis is show in the figure below.
  55 //Begin_Html
  56 /*
  57 <img src="picts/ITS/ITS_Analysis_schema.gif">
  58 </pre>
  59 <br clear=left>
  60 <font size=+2 color=red>
  61 <p>Roberto Barbera is in charge of the ITS Offline code (1999).
  62 <a href="mailto:roberto.barbera@ct.infn.it">Roberto Barbera</a>.
  63 </font>
  64 <pre>
  65 */
  66 //End_Html
  67 //
  68 //  AliITS. Inner Traking System base class.
  69 //  This class contains the base procedures for the Inner Tracking System
  70 //
  71 //Begin_Html
  72 /*
  73 <img src="picts/ITS/AliITS_Class_Diagram.gif">
  74 </pre>
  75 <br clear=left>
  76 <font size=+2 color=red>
  77 <p>This show the class diagram of the different elements that are part of
  78 the AliITS class.
  79 </font>
  80 <pre>
  81 */
  82 //End_Html
  83 //
  84 // Version: 0
  85 // Written by Rene Brun, Federico Carminati, and Roberto Barbera
  86 //
  87 // Version: 1
  88 // Modified and documented by Bjorn S. Nilsen
  89 // July 11 1999
  90 //
  91 // Version: 2
  92 // Modified and documented by A. Bologna
  93 // October 18 1999
  94 //
  95 // AliITS is the general base class for the ITS. Also see AliDetector for
  96 // futher information.
  97 //
  98 ///////////////////////////////////////////////////////////////////////////////
  99
 100 #include <TMath.h>
 101 #include <TRandom.h>
 102 #include <TVector.h>
 103 #include <TObjArray.h>
 104 #include <TClonesArray.h>
 105 #include <TROOT.h>
 106 #include <TObjectTable.h>
 107
 108
 109
 110 #include "AliRun.h"
 111 #include "AliITS.h"
 112 #include "AliITSMap.h"
 113 #include "AliITSClusterFinder.h"
 114 #include "AliITSsimulation.h"
 115 #include "AliITSsimulationFastPoints.h"
 116 #include "AliITSsegmentationSPD.h"
 117 #include "AliITSresponseSPD.h"
 118 #include "AliITSsegmentationSDD.h"
 119 #include "AliITSresponseSDD.h"
 120 #include "AliITSsegmentationSSD.h"
 121 #include "AliITSresponseSSD.h"
 122 //#include "AliITStrack.h"
 123
 124
 125 ClassImp(AliITS)
 126
 127 //_____________________________________________________________________________
 128 AliITS::AliITS() : AliDetector() {
 129   //
 130   // Default initialiser for ITS
 131   //     The default constructor of the AliITS class. In addition to
 132   // creating the AliITS class it zeros the variables fIshunt (a member
 133   // of AliDetector class), fEuclidOut, and fIdN, and zeros the pointers
 134   // fITSpoints, fIdSens, and fIdName. The AliDetector default constructor
 135   // is also called.
 136   //
 137
 138   fIshunt     = 0;
 139   fEuclidOut  = 0;
 140   fIdN        = 0;
 141   fIdName     = 0;
 142   fIdSens     = 0;
 143   fITSmodules = 0;
 144   //
 145   fDetTypes   = 0;
 146   SetNDetTypes();
 147   //
 148   fDtype  = 0;
 149   fNdtype = 0;
 150   fCtype  = 0;
 151   fNctype = 0;
 152   fRecPoints = 0;
 153   fNRecPoints = 0;
 154   //
 155   fITSgeom=0;
 156 }
 157
 158 //_____________________________________________________________________________
 159 AliITS::AliITS(const char *name, const char *title):AliDetector(name,title){
 160   //
 161   // Default initialiser for ITS
 162   //     The constructor of the AliITS class. In addition to creating the
 163   // AliITS class, it allocates memory for the TClonesArrays fHits and
 164   // fDigits, and for the TObjArray fITSpoints. It also zeros the variables
 165   // fIshunt (a member of AliDetector class), fEuclidOut, and fIdN, and zeros
 166   // the pointers fIdSens and fIdName. To help in displaying hits via the ROOT
 167   // macro display.C AliITS also sets the marker color to red. The variables
 168   // passes with this constructor, const char *name and *title, are used by
 169   // the constructor of AliDetector class. See AliDetector class for a
 170   // description of these parameters and its constructor functions.
 171   //
 172
 173   fHits       = new TClonesArray("AliITShit", 1560);
 174   gAlice->AddHitList(fHits);
 175
 176   SetNDetTypes();
 177
 178   fNdtype = 0;
 179   fDtype = 0;
 180   fCtype  = 0;
 181   fNctype = 0;
 182
 183   fRecPoints = 0;
 184   fNRecPoints = 0;
 185
 186
 187   fITSmodules = 0;
 188
 189   fIshunt     = 0;
 190   fEuclidOut  = 0;
 191   fIdN        = 0;
 192   fIdName     = 0;
 193   fIdSens     = 0;
 194
 195   fDetTypes = new TObjArray(fNDetTypes);
 196
 197   Int_t i;
 198   for(i=0;i<fNDetTypes;i++) {
 199     (*fDetTypes)[i]=new AliITSDetType();
 200    }
 201   //
 202
 203    fNdtype = new Int_t[fNDetTypes];
 204    fDtype = new TObjArray(fNDetTypes);
 205
 206    fNctype = new Int_t[fNDetTypes];
 207    fCtype = new TObjArray(fNDetTypes);
 208
 209   SetMarkerColor(kRed);
 210
 211   fITSgeom=0;
 212 }
 213 //___________________________________________________________________________
 214 AliITS::AliITS(AliITS &source){
 215   if(this==&source) return;
 216   printf("Error: You are not allowed to make a copy of the AliITS\n");
 217   exit(1);
 218 }
 219 //____________________________________________________________________________
 220 AliITS& AliITS::operator=(AliITS &source){
 221   if(this==&source) return *this;
 222   printf("Error: You are not allowed to make a copy of the AliITS\n");
 223   exit(1);
 224 }
 225 //____________________________________________________________________________
 226 void AliITS::ClearModules(){
 227   //clear the modules TObjArray
 228   Int_t i;
 229
 230   if(fITSmodules!=0) {
 231         Int_t indSPD = fITSgeom->GetModuleIndex(2,fITSgeom->GetNladders(2),
 232                                                 fITSgeom->GetNdetectors(2));
 233         Int_t indSDD = fITSgeom->GetModuleIndex(4,fITSgeom->GetNladders(4),
 234                                                 fITSgeom->GetNdetectors(4));
 235       for(i=0;i<fITSmodules->GetEntriesFast();i++){
 236             if(i<indSPD)
 237                 delete (AliITSmodule *) fITSmodules->At(i);
 238             else if(i<indSDD)
 239                 delete (AliITSmodule *) fITSmodules->At(i);
 240             else
 241                 delete (AliITSmodule *) fITSmodules->At(i);
 242       } // end for i
 243   }// end if fITSmodules!=0
 244
 245 }
 246 //_____________________________________________________________________________
 247 AliITS::~AliITS(){
 248   //
 249   // Default distructor for ITS
 250   //     The default destructor of the AliITS class. In addition to deleting
 251   // the AliITS class it deletes the memory pointed to by the fHits, fDigits,
 252   // fIdSens, fIdName, and fITSpoints.
 253   //
 254
 255
 256   delete fHits;
 257   delete fDigits;
 258   delete fRecPoints;
 259   if(fIdName!=0) delete[] fIdName;
 260   if(fIdSens!=0) delete[] fIdSens;
 261   if(fITSmodules!=0) {
 262       this->ClearModules();
 263       delete fITSmodules;
 264   }// end if fITSmodules!=0
 265
 266   //
 267   Int_t i;
 268   if(fDtype) {
 269     for(i=0;i<fNDetTypes;i++) {
 270       delete (*fDtype)[i];
 271       fNdtype[i]=0;
 272     }
 273   }
 274
 275   for(i=0;i<fNDetTypes;i++) {
 276       delete (*fCtype)[i];
 277       fNctype[i]=0;
 278   }
 279
 280   //
 281
 282   if (fDetTypes) {
 283     fDetTypes->Delete();
 284     delete fDetTypes;
 285   }
 286
 287   if (fTreeC) delete fTreeC;
 288
 289 }
 290
 291 //___________________________________________
 292 AliITSDetType* AliITS::DetType(Int_t id)
 293 {
 294   //return pointer to id detector type
 295     return ((AliITSDetType*) (*fDetTypes)[id]);
 296
 297 }
 298 //___________________________________________
 299 void AliITS::SetClasses(Int_t id, char* digit, char* cluster)
 300 {
 301   //set the digit and cluster classes to be used for the id detector type
 302     ((AliITSDetType*) (*fDetTypes)[id])->ClassNames(digit,cluster);
 303
 304 }
 305 //___________________________________________
 306 void AliITS::SetResponseModel(Int_t id, AliITSresponse *response)
 307 {
 308   //set the response model for the id detector type
 309
 310     ((AliITSDetType*) (*fDetTypes)[id])->ResponseModel(response);
 311
 312 }
 313
 314 //___________________________________________
 315 void AliITS::SetSegmentationModel(Int_t id, AliITSsegmentation *seg)
 316 {
 317   //set the segmentation model for the id detector type
 318
 319     ((AliITSDetType*) (*fDetTypes)[id])->SegmentationModel(seg);
 320
 321 }
 322
 323 //___________________________________________
 324 void AliITS::SetSimulationModel(Int_t id, AliITSsimulation *sim)
 325 {
 326   //set the simulation model for the id detector type
 327
 328    ((AliITSDetType*) (*fDetTypes)[id])->SimulationModel(sim);
 329
 330 }
 331 //___________________________________________
 332 void AliITS::SetReconstructionModel(Int_t id, AliITSClusterFinder *reconst)
 333 {
 334   //set the cluster finder model for the id detector type
 335
 336    ((AliITSDetType*) (*fDetTypes)[id])->ReconstructionModel(reconst);
 337
 338 }
 339
 340 //_____________________________________________________________________________
 341 void AliITS::AddHit(Int_t track, Int_t *vol, Float_t *hits){
 342   //
 343   // Add an ITS hit
 344   //     The function to add information to the AliITShit class. See the
 345   // AliITShit class for a full description. This function allocates the
 346   // necessary new space for the hit information and passes the variable
 347   // track, and the pointers *vol and *hits to the AliITShit constructor
 348   // function.
 349   //
 350   TClonesArray &lhits = *fHits;
 351   new(lhits[fNhits++]) AliITShit(fIshunt,track,vol,hits);
 352 }
 353 //_____________________________________________________________________________
 354 void AliITS::AddRealDigit(Int_t id, Int_t *digits)
 355 {
 356   // add a real digit - as coming from data
 357
 358   TClonesArray &ldigits = *((TClonesArray*)(*fDtype)[id]);
 359   new(ldigits[fNdtype[id]++]) AliITSdigit(digits);
 360
 361 }
 362 //_____________________________________________________________________________
 363 void AliITS::AddDigit(Int_t id, AliITSdigit *d)
 364 {
 365
 366   // add a simulated digit
 367
 368   // should have ctors of type AliITSdigitSDD(const AliITSdigitSDD &)
 369
 370   TClonesArray &ldigits = *((TClonesArray*)(*fDtype)[id]);
 371
 372   switch(id)
 373   {
 374   case 0:
 375      new(ldigits[fNdtype[id]++]) AliITSdigitSPD(*((AliITSdigitSPD*)d));
 376      break;
 377   case 1:
 378      new(ldigits[fNdtype[id]++]) AliITSdigitSDD(*((AliITSdigitSDD*)d));
 379      break;
 380   case 2:
 381      new(ldigits[fNdtype[id]++]) AliITSdigitSSD(*((AliITSdigitSSD*)d));
 382      break;
 383   }
 384
 385 }
 386
 387 //_____________________________________________________________________________
 388 void AliITS::AddDigit(Int_t id,Float_t phys,Int_t *digits,Int_t *tracks,Float_t *charges){
 389
 390   // add a simulated digit to the list
 391
 392   TClonesArray &ldigits = *((TClonesArray*)(*fDtype)[id]);
 393   switch(id)
 394   {
 395   case 0:
 396      new(ldigits[fNdtype[id]++]) AliITSdigitSPD(digits,tracks);
 397      break;
 398   case 1:
 399      new(ldigits[fNdtype[id]++]) AliITSdigitSDD(phys,digits,tracks,charges);
 400      break;
 401   case 2:
 402      new(ldigits[fNdtype[id]++]) AliITSdigitSSD(digits,tracks);
 403      break;
 404   }
 405
 406 }
 407
 408 //_____________________________________________________________________________
 409 void AliITS::AddCluster(Int_t id, AliITSRawCluster *c)
 410 {
 411
 412   // add a cluster to the list
 413
 414   // should have ctors of type AliITSRawClusterSDD(const AliITSRawClusterSDD &)
 415
 416   TClonesArray &lcl = *((TClonesArray*)(*fCtype)[id]);
 417
 418   switch(id)
 419   {
 420   case 0:
 421      new(lcl[fNctype[id]++]) AliITSRawClusterSPD(*((AliITSRawClusterSPD*)c));
 422      break;
 423   case 1:
 424      new(lcl[fNctype[id]++]) AliITSRawClusterSDD(*((AliITSRawClusterSDD*)c));
 425      break;
 426   case 2:
 427      new(lcl[fNctype[id]++]) AliITSRawClusterSSD(*((AliITSRawClusterSSD*)c));
 428      break;
 429   }
 430
 431 }
 432
 433
 434 //_____________________________________________________________________________
 435 void AliITS::AddRecPoint(const AliITSRecPoint &r)
 436 {
 437   //
 438   // Add a reconstructed space point to the list
 439   //
 440   TClonesArray &lrecp = *fRecPoints;
 441   new(lrecp[fNRecPoints++]) AliITSRecPoint(r);
 442 }
 443
 444
 445 //____________________________________________
 446 void AliITS::ResetDigits()
 447 {
 448     //
 449     // Reset number of digits and the digits array for thE ITS detector
 450     //
 451
 452     if (!fDtype) return;
 453
 454     Int_t i;
 455     for(i=0;i<fNDetTypes;i++ ) {
 456         if ((*fDtype)[i])    ((TClonesArray*)(*fDtype)[i])->Clear();
 457         if (fNdtype)  fNdtype[i]=0;
 458     }
 459 }
 460
 461 //____________________________________________
 462 void AliITS::ResetDigits(Int_t i)
 463 {
 464     //
 465     // Reset number of digits and the digits array for this branch
 466     //
 467         if ((*fDtype)[i])    ((TClonesArray*)(*fDtype)[i])->Clear();
 468         if (fNdtype)  fNdtype[i]=0;
 469
 470 }
 471 //____________________________________________
 472 void AliITS::ResetClusters()
 473 {
 474     //
 475     // Reset number of clusters and the clusters array for ITS
 476     //
 477
 478     Int_t i;
 479     for(i=0;i<fNDetTypes;i++ ) {
 480         if ((*fCtype)[i])    ((TClonesArray*)(*fCtype)[i])->Clear();
 481         if (fNctype)  fNctype[i]=0;
 482     }
 483
 484 }
 485 //____________________________________________
 486 void AliITS::ResetClusters(Int_t i)
 487 {
 488     //
 489     // Reset number of clusters and the clusters array for this branch
 490     //
 491         if ((*fCtype)[i])    ((TClonesArray*)(*fCtype)[i])->Clear();
 492         if (fNctype)  fNctype[i]=0;
 493
 494 }
 495
 496
 497 //____________________________________________
 498 void AliITS::ResetRecPoints()
 499 {
 500     //
 501     // Reset number of rec points and the rec points array
 502     //
 503     fNRecPoints = 0;
 504     if (fRecPoints) fRecPoints->Clear();
 505
 506 }
 507
 508 //_____________________________________________________________________________
 509 Int_t AliITS::DistancetoPrimitive(Int_t , Int_t ){
 510   //
 511   // Distance from mouse to ITS on the screen. Dummy routine
 512   //     A dummy routine used by the ROOT macro display.C to allow for the
 513   // use of the mouse (pointing device) in the macro. In general this should
 514   // never be called. If it is it returns the number 9999 for any value of
 515   // x and y.
 516   //
 517   return 9999;
 518 }
 519
 520 //_____________________________________________________________________________
 521 void AliITS::Init(){
 522   //
 523   // Initialise ITS after it has been built
 524   //     This routine initializes the AliITS class. It is intended to be called
 525   // from the Init function in AliITSv?. Besides displaying a banner
 526   // indicating that it has been called it initializes the array fIdSens
 527   // and sets the default segmentation, response, digit and raw cluster classes
 528   // Therefore it should be called after a call to CreateGeometry.
 529   //
 530
 531
 532   SetDefaults();
 533
 534   Int_t i;
 535
 536   printf("\n");
 537   for(i=0;i<35;i++) printf("*");
 538   printf(" ITS_INIT ");
 539   for(i=0;i<35;i++) printf("*");
 540   printf("\n");
 541   //
 542   //
 543   for(i=0;i<fIdN;i++) fIdSens[i] = gMC->VolId(fIdName[i]);
 544   //
 545   for(i=0;i<80;i++) printf("*");
 546   printf("\n");
 547 }
 548
 549 //_____________________________________________________________________________
 550 void AliITS::SetDefaults()
 551 {
 552   // sets the default segmentation, response, digit and raw cluster classes
 553
 554
 555   AliITSDetType *iDetType;
 556
 557   //SPD
 558
 559   AliITSsegmentationSPD *seg0=new AliITSsegmentationSPD(fITSgeom);
 560   AliITSresponseSPD *resp0=new AliITSresponseSPD();
 561   iDetType=DetType(0);
 562   if (!iDetType->GetSegmentationModel()) SetSegmentationModel(0,seg0);
 563   if (!iDetType->GetResponseModel()) SetResponseModel(0,resp0);
 564   // set digit and raw cluster classes to be used
 565   const char *kData=resp0->DataType();
 566   if (strstr(kData,"real")) {
 567       iDetType->ClassNames("AliITSdigit","AliITSRawClusterSPD");
 568   } else iDetType->ClassNames("AliITSdigitSPD","AliITSRawClusterSPD");
 569
 570   // SDD                                          //
 571   AliITSresponseSDD *resp1=new AliITSresponseSDD();
 572   AliITSsegmentationSDD *seg1=new AliITSsegmentationSDD(fITSgeom,resp1);
 573   iDetType=DetType(1);
 574   if (!iDetType->GetSegmentationModel()) SetSegmentationModel(1,seg1);
 575   if (!iDetType->GetResponseModel()) SetResponseModel(1,resp1);
 576   kData=resp1->DataType();
 577   Option_t *opt=resp1->ZeroSuppOption();
 578   if ((!strstr(opt,"2D")) && (!strstr(opt,"1D")) || strstr(kData,"real") ) {
 579       iDetType->ClassNames("AliITSdigit","AliITSRawClusterSDD");
 580   } else iDetType->ClassNames("AliITSdigitSDD","AliITSRawClusterSDD");
 581
 582   // SSD
 583   AliITSsegmentationSSD *seg2=new AliITSsegmentationSSD(fITSgeom);
 584   AliITSresponseSSD *resp2=new AliITSresponseSSD();
 585   iDetType=DetType(2);
 586   if (!iDetType->GetSegmentationModel()) SetSegmentationModel(2,seg2);
 587   if (!iDetType->GetResponseModel()) SetResponseModel(2,resp2);
 588   kData=resp2->DataType();
 589   if (strstr(kData,"real")) {
 590       iDetType->ClassNames("AliITSdigit","AliITSRawClusterSSD");
 591   } else iDetType->ClassNames("AliITSdigitSSD","AliITSRawClusterSSD");
 592
 593   if (fNDetTypes>3) {
 594     Warning("SetDefaults","Only the three basic detector types are initialised!");
 595   }
 596
 597 }
 598
 599
 600 //_____________________________________________________________________________
 601
 602 void AliITS::MakeTreeC(Option_t *option)
 603 {
 604   // create a separate tree to store the clusters
 605
 606      char *optC = strstr(option,"C");
 607      if (optC && !fTreeC) fTreeC = new TTree("TC","Clusters in ITS");
 608
 609      Int_t buffersize = 4000;
 610      char branchname[30];
 611
 612      char *det[3] = {"SPD","SDD","SSD"};
 613
 614      // one branch for Clusters per type of detector
 615      Int_t i;
 616      for(i=0; i<fNDetTypes ;i++) {
 617         if (fNDetTypes==3) sprintf(branchname,"%sClusters%s",GetName(),det[i]);
 618         else  sprintf(branchname,"%sClusters%d",GetName(),i+1);
 619         if (fCtype   && fTreeC) {
 620            TreeC()->Branch(branchname,&((*fCtype)[i]), buffersize);
 621            printf("Making Branch %s for Clusters of detector type %d\n",branchname,i+1);
 622         }
 623      }
 624
 625 }
 626
 627 //_____________________________________________________________________________
 628 void AliITS::GetTreeC(Int_t event)
 629 {
 630
 631   // get the clusters tree for this event and set the branch address
 632     char treeName[20];
 633     char branchname[30];
 634
 635     char *det[3] = {"SPD","SDD","SSD"};
 636
 637     ResetClusters();
 638     if (fTreeC) {
 639           delete fTreeC;
 640     }
 641
 642     sprintf(treeName,"TreeC%d",event);
 643     fTreeC = (TTree*)gDirectory->Get(treeName);
 644
 645
 646     TBranch *branch;
 647     if (fTreeC) {
 648         Int_t i;
 649         for(i=0; i<fNDetTypes; i++) {
 650             if (fNDetTypes==3) sprintf(branchname,"%sClusters%s",GetName(),det[i]);
 651             else  sprintf(branchname,"%sClusters%d",GetName(),i+1);
 652             if (fCtype) {
 653                 branch = fTreeC->GetBranch(branchname);
 654                 if (branch) branch->SetAddress(&((*fCtype)[i]));
 655             }
 656         }
 657     } else {
 658         printf("ERROR: cannot find Clusters Tree for event:%d\n",event);
 659     }
 660
 661 }
 662 //_____________________________________________________________________________
 663 void AliITS::MakeBranch(Option_t* option){
 664   //
 665   // Creates Tree branches for the ITS.
 666   //
 667
 668
 669   Int_t buffersize = 4000;
 670   char branchname[30];
 671   sprintf(branchname,"%s",GetName());
 672
 673   AliDetector::MakeBranch(option);
 674
 675
 676 // one branch for digits per type of detector
 677
 678    char *det[3] = {"SPD","SDD","SSD"};
 679
 680    char *kDigclass;
 681    char *kClclass;
 682
 683    Int_t i;
 684    for(i=0; i<fNDetTypes ;i++) {
 685        AliITSDetType *iDetType=DetType(i);
 686        iDetType->GetClassNames(kDigclass,kClclass);
 687        //printf("i, digclass, recclass %d %s %s\n",i,kDigclass,kClclass);
 688        // digits
 689        (*fDtype)[i] = new TClonesArray(kDigclass,100);
 690        fNdtype[i]=0;
 691        // clusters
 692        (*fCtype)[i] = new TClonesArray(kClclass,100);
 693        fNctype[i]=0;
 694    }
 695
 696
 697   for(i=0; i<fNDetTypes ;i++) {
 698       if (fNDetTypes==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
 699       else  sprintf(branchname,"%sDigits%d",GetName(),i+1);
 700
 701       if (fDtype   && gAlice->TreeD()) {
 702           gAlice->TreeD()->Branch(branchname,&((*fDtype)[i]), buffersize);
 703           printf("Making Branch %s for digits of type %d\n",branchname,i+1);
 704       }
 705   }
 706
 707   // only one branch for rec points for all detector types
 708   sprintf(branchname,"%sRecPoints",GetName());
 709
 710   fRecPoints=new TClonesArray("AliITSRecPoint",1000);
 711
 712   if (fRecPoints && gAlice->TreeR()) {
 713     gAlice->TreeR()->Branch(branchname,&fRecPoints, buffersize);
 714     printf("Making Branch %s for reconstructed space points\n",branchname);
 715   }
 716
 717
 718 }
 719
 720 //___________________________________________
 721 void AliITS::SetTreeAddress()
 722 {
 723
 724   // Set branch address for the Trees.
 725
 726   char branchname[30];
 727   AliDetector::SetTreeAddress();
 728
 729   char *det[3] = {"SPD","SDD","SSD"};
 730
 731   TBranch *branch;
 732   TTree *treeD = gAlice->TreeD();
 733   TTree *treeR = gAlice->TreeR();
 734
 735   Int_t i;
 736   if (treeD) {
 737       for(i=0; i<fNDetTypes; i++) {
 738           if (fNDetTypes==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
 739           else  sprintf(branchname,"%sDigits%d",GetName(),i+1);
 740           if (fDtype) {
 741               branch = treeD->GetBranch(branchname);
 742               if (branch) branch->SetAddress(&((*fDtype)[i]));
 743           }
 744       }
 745   }
 746
 747
 748   if (treeR) {
 749     sprintf(branchname,"%sRecPoints",GetName());
 750     if (fRecPoints) {
 751       branch = treeR->GetBranch(branchname);
 752       if (branch) branch->SetAddress(&fRecPoints);
 753     }
 754   }
 755
 756
 757 }
 758
 759 //____________________________________________________________________________
 760 void AliITS::InitModules(Int_t size,Int_t &nmodules){
 761
 762   //initialize the modules array
 763
 764     Int_t nl,indexMAX,index;
 765     Int_t indSPD,indSDD;
 766
 767     if(size<=0){ // default to using data stored in AliITSgeom
 768         if(fITSgeom==0) {
 769             printf("Error in AliITS::InitModule fITSgeom not defined\n");
 770             return;
 771         } // end if fITSgeom==0
 772         nl = fITSgeom->GetNlayers();
 773         indexMAX = fITSgeom->GetModuleIndex(nl,fITSgeom->GetNladders(nl),
 774                                             fITSgeom->GetNdetectors(nl))+1;
 775         nmodules = indexMAX;
 776         fITSmodules = new TObjArray(indexMAX);
 777         indSPD = fITSgeom->GetModuleIndex(2,fITSgeom->GetNladders(2),
 778                                             fITSgeom->GetNdetectors(2));
 779         indSDD = fITSgeom->GetModuleIndex(4,fITSgeom->GetNladders(4),
 780                                             fITSgeom->GetNdetectors(4));
 781         for(index=0;index<indexMAX;index++){
 782             if(index<=indSPD)
 783                 fITSmodules->AddAt( new AliITSmodule(index),index);
 784             else if(index<=indSDD)
 785                 fITSmodules->AddAt( new AliITSmodule(index),index);
 786             else
 787                 fITSmodules->AddAt( new AliITSmodule(index),index);
 788         } // end for index
 789     }else{
 790         fITSmodules = new TObjArray(size);
 791         nmodules = size;
 792     } // end i size<=0
 793 }
 794
 795 //____________________________________________________________________________
 796 void AliITS::FillModules(Int_t evnt,Int_t bgrev,Int_t lastev,Int_t nmodules,Option_t *option,Text_t *filename){
 797
 798   // fill the modules with the sorted by module hits; add hits from background
 799   // if option=Add
 800
 801     static TTree *trH1;                 //Tree with background hits
 802     static TClonesArray *fHits2;        //List of hits for one track only
 803
 804     static Bool_t first=kTRUE;
 805     static TFile *file;
 806     char *add = strstr(option,"Add");
 807
 808
 809     if (add ) {
 810         if(first) {
 811             cout<<"filename "<<filename<<endl;
 812             file=new TFile(filename);
 813             cout<<"I have opened "<<filename<<" file "<<endl;
 814             fHits2     = new TClonesArray("AliITShit",1000  );
 815         }
 816         first=kFALSE;
 817         file->cd();
 818         file->ls();
 819         // Get Hits Tree header from file
 820         if(fHits2) fHits2->Clear();
 821         if(trH1) delete trH1;
 822         trH1=0;
 823
 824         char treeName[20];
 825         sprintf(treeName,"TreeH%d",bgrev);
 826         trH1 = (TTree*)gDirectory->Get(treeName);
 827         //printf("TrH1 %p of treename %s for event %d \n",trH1,treeName,bgrev);
 828
 829         if (!trH1) {
 830             printf("ERROR: cannot find Hits Tree for event:%d\n",bgrev);
 831         }
 832         // Set branch addresses
 833         TBranch *branch;
 834         char branchname[20];
 835         sprintf(branchname,"%s",GetName());
 836         if (trH1 && fHits2) {
 837             branch = trH1->GetBranch(branchname);
 838             if (branch) branch->SetAddress(&fHits2);
 839         }
 840
 841         // test
 842         //Int_t ntracks1 =(Int_t)TrH1->GetEntries();
 843         //printf("background - ntracks1 - %d\n",ntracks1);
 844    }
 845
 846     // store temporarily coordinates of signal particles - see where delete
 847     static Int_t *signal;
 848     Int_t i;
 849     if(!signal) signal=new Int_t[nmodules];
 850     memset(signal,0,sizeof(int)*nmodules);
 851 //    Float_t xhit[nmodules][4];
 852     Float_t **xhit = new Float_t*[nmodules];
 853     for(i=0;i<nmodules;i++) xhit[i] = new Float_t[4];
 854 //    Float_t yhit[nmodules][4];
 855     Float_t **yhit = new Float_t*[nmodules];
 856     for(i=0;i<nmodules;i++) yhit[i] = new Float_t[4];
 857
 858     Int_t npart = gAlice->GetEvent(evnt);
 859     if(npart<=0) return;
 860     TClonesArray *itsHits = this->Hits();
 861     Int_t lay,lad,det,index;
 862     AliITShit *itsHit=0;
 863     AliITSmodule *mod=0;
 864
 865     TTree *iTH = gAlice->TreeH();
 866     Int_t ntracks =(Int_t) iTH->GetEntries();
 867
 868     Int_t t,h;
 869     for(t=0; t<ntracks; t++){
 870         gAlice->ResetHits();
 871         iTH->GetEvent(t);
 872         Int_t nhits = itsHits->GetEntriesFast();
 873         if (!nhits) continue;
 874         // cout << nhits << " hits in track " << t << endl;
 875         for(h=0; h<nhits; h++){
 876             itsHit = (AliITShit *)itsHits->UncheckedAt(h);
 877             itsHit->GetDetectorID(lay,lad,det);
 878             index = fITSgeom->GetModuleIndex(lay,lad,det);
 879             mod = this->GetModule(index);
 880             if (add) {
 881                 xhit[index][signal[index]]=itsHit->fX;
 882                 yhit[index][signal[index]]=itsHit->fY;
 883                 signal[index]++;
 884                 if (signal[index] >4)
 885                       printf("index,nsignal %d %d\n",index,signal[index]);
 886             }
 887             if(lay == 1 || lay == 2)
 888                 mod->AddHit((AliITShit *) itsHit,t,h);
 889             else if(lay == 3 || lay == 4)
 890                     mod->AddHit((AliITShit *) itsHit,t,h);
 891             else if(lay == 5 || lay ==6)
 892                 mod->AddHit((AliITShit *)itsHit,t,h);
 893             else
 894                 mod->AddHit(itsHit,t,h);
 895
 896         } // end loop over hits
 897     } // end loop over tracks
 898
 899     // open the file with background
 900
 901     if (add ) {
 902           Int_t track,i,isig;
 903           ntracks =(Int_t)trH1->GetEntries();
 904             //printf("background - ntracks1 %d\n",ntracks);
 905             //printf("background - Start loop over tracks \n");
 906             //   Loop over tracks
 907
 908             for(track=0; track<ntracks; track++) {
 909
 910                 if (fHits2)       fHits2->Clear();
 911                 trH1->GetEvent(track);
 912                 //   Loop over hits
 913                 for(i=0;i<fHits2->GetEntriesFast();++i) {
 914
 915                     itsHit=(AliITShit*) (*fHits2)[i];
 916                     itsHit->GetDetectorID(lay,lad,det);
 917                     index = fITSgeom->GetModuleIndex(lay,lad,det);
 918                     mod = this->GetModule(index);
 919
 920                     Float_t xbgr=itsHit->fX;
 921                     Float_t ybgr=itsHit->fY;
 922                     Float_t ebgr=itsHit->GetIonization();
 923                     Bool_t cond=kFALSE;
 924
 925                     for(isig =0; isig < signal[index]; isig++) {
 926                         Float_t dist=
 927                             (xbgr-xhit[index][isig])*(xbgr-xhit[index][isig])
 928                             +(ybgr-yhit[index][isig])*(ybgr-yhit[index][isig]);
 929                         if (dist<0.2&& ebgr!=0) cond=kTRUE; // check this number for ITS!
 930                     }
 931                     if (!cond) continue;
 932                     if(lay == 1 || lay == 2)
 933                        mod->AddHit((AliITShit *) itsHit,track,i);
 934                     else if(lay == 3 || lay == 4)
 935                             mod->AddHit((AliITShit *) itsHit,track,i);
 936                     else if(lay == 5 || lay ==6)
 937                             mod->AddHit((AliITShit *)itsHit,track,i);
 938                     else
 939                        mod->AddHit(itsHit,track,i);
 940
 941
 942                }  // end loop over hits
 943             } // end loop over tracks
 944
 945             TTree *fAli=gAlice->TreeK();
 946             TFile *fileAli=0;
 947
 948             if (fAli) fileAli =fAli->GetCurrentFile();
 949             //printf("fAli, file %p %p\n",fAli,file);
 950             file->cd();
 951
 952     } // end if add
 953
 954
 955     for(i=0;i<nmodules;i++) delete[] xhit[i];
 956     delete[] xhit;
 957     for(i=0;i<nmodules;i++) delete[] yhit[i];
 958     delete[] yhit;
 959     //if (evnt==lastev) {delete [] signal; delete signal;}
 960
 961     //gObjectTable->Print();
 962
 963 }
 964
 965
 966 //____________________________________________________________________________
 967 void AliITS::HitsToDigits(Int_t evNumber,Int_t bgrev,Int_t lastev,Int_t size,
 968 Option_t *option,Option_t *opt,Text_t *filename)
 969 {
 970     // keep galice.root for signal and name differently the file for
 971     // background when add! otherwise the track info for signal will be lost !
 972
 973    char *all = strstr(opt,"All");
 974    char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),strstr(opt,"SSD")};
 975    //printf("Det 1 2 3 %s %s %s \n",det[0],det[1],det[2]);
 976
 977    Int_t nmodules;
 978    InitModules(size,nmodules);
 979    FillModules(evNumber,bgrev,lastev,nmodules,option,filename);
 980    //printf("nmodules %d\n",nmodules);
 981
 982    TBranch *branch;
 983    AliITSsimulation* sim;
 984
 985    TObjArray *branches=gAlice->TreeD()->GetListOfBranches();
 986    AliITSgeom *geom = GetITSgeom();
 987
 988    Int_t id,module;
 989    for(id=0;id<3;id++) {
 990         //printf("id %d All %s  det[id] %s \n",id,all,det[id]);
 991         if (!all && !det[id]) continue;
 992         branch = (TBranch*)branches->UncheckedAt(id);
 993         AliITSDetType *iDetType=DetType(id);
 994         sim = (AliITSsimulation*)iDetType->GetSimulationModel();
 995         if (!sim) {
 996            Error("HitsToDigits","The simulation class was not instantiated!");
 997            exit(1);
 998            // or SetDefaultSimulation(id,iDetType*);
 999         }
1000         Int_t first = geom->GetStartDet(id);
1001         Int_t last = geom->GetLastDet(id);
1002         //printf("det type %d first, last %d %d \n",id,first,last);
1003         for(module=first;module<=last;module++) {
1004             AliITSmodule *mod = (AliITSmodule *)fITSmodules->At(module);
1005             sim->DigitiseModule(mod,module,evNumber);
1006             // fills all branches - wasted disk space
1007             gAlice->TreeD()->Fill();
1008             ResetDigits();
1009             // try and fill only the branch
1010             //branch->Fill();
1011             //ResetDigits(id);
1012         } // loop over modules
1013    } // loop over detector types
1014
1015
1016    ClearModules();
1017
1018    //Int_t nentries=(Int_t)gAlice->TreeD()->GetEntries();
1019
1020    char hname[30];
1021    sprintf(hname,"TreeD%d",evNumber);
1022    gAlice->TreeD()->Write(hname);
1023    // reset tree
1024    gAlice->TreeD()->Reset();
1025
1026 }
1027
1028
1029 //____________________________________________________________________________
1030 void AliITS::DigitsToRecPoints(Int_t evNumber,Int_t lastentry,Option_t *opt)
1031 {
1032
1033    char *all = strstr(opt,"All");
1034    char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),strstr(opt,"SSD")};
1035
1036    static Bool_t first=kTRUE;
1037    if (first) {
1038        MakeTreeC("C");
1039        first=kFALSE;
1040    }
1041    TTree *iTC=TreeC();
1042
1043    TBranch *branch;
1044    AliITSClusterFinder* rec;
1045
1046    TObjArray *branches=gAlice->TreeR()->GetListOfBranches();
1047    AliITSgeom *geom = GetITSgeom();
1048
1049    Int_t id,module;
1050    for(id=0;id<fNDetTypes;id++) {
1051         if (!all && !det[id]) continue;
1052         branch = (TBranch*)branches->UncheckedAt(id);
1053         AliITSDetType *iDetType=DetType(id);
1054         rec = (AliITSClusterFinder*)iDetType->GetReconstructionModel();
1055         if (!rec) {
1056            Error("DigitsToRecPoints","The cluster finder class was not instantiated!");
1057            exit(1);
1058            // or SetDefaultClusterFinder(id,iDetType*);
1059         }
1060         TClonesArray *itsDigits  = this->DigitsAddress(id);
1061
1062         Int_t first = geom->GetStartDet(id);
1063         Int_t last = geom->GetLastDet(id);
1064         //printf("det type %d first, last %d %d \n",id,first,last);
1065         for(module=first;module<=last;module++) {
1066               //printf("AliITS: module=%d\n",module);
1067               this->ResetDigits();
1068               if (all) gAlice->TreeD()->GetEvent(lastentry+module);
1069               else gAlice->TreeD()->GetEvent(lastentry+(module-first));
1070               Int_t ndigits = itsDigits->GetEntriesFast();
1071               if (ndigits) rec->FindRawClusters();
1072               gAlice->TreeR()->Fill();
1073               ResetRecPoints();
1074               iTC->Fill();
1075               ResetClusters();
1076               // try and fill only the branch
1077               //branch->Fill();
1078               //ResetRecPoints(id);
1079         } // loop over modules
1080    } // loop over detector types
1081
1082
1083    //Int_t nentries=(Int_t)gAlice->TreeR()->GetEntries();
1084
1085    //Int_t ncentries=(Int_t)TC->GetEntries();
1086
1087    char hname[30];
1088    sprintf(hname,"TreeR%d",evNumber);
1089    gAlice->TreeR()->Write(hname);
1090    // reset tree
1091    gAlice->TreeR()->Reset();
1092
1093    sprintf(hname,"TreeC%d",evNumber);
1094    iTC->Write(hname);
1095    iTC->Reset();
1096 }
1097
1098
1099 //____________________________________________________________________________
1100 void AliITS::HitsToFastRecPoints(Int_t evNumber,Int_t bgrev,Int_t lastev,Int_t size,
1101 Option_t *option,Option_t *opt,Text_t *filename)
1102 {
1103     // keep galice.root for signal and name differently the file for
1104     // background when add! otherwise the track info for signal will be lost !
1105
1106    char *all = strstr(opt,"All");
1107    char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),strstr(opt,"SSD")};
1108
1109    Int_t nmodules;
1110    InitModules(size,nmodules);
1111    FillModules(evNumber,bgrev,lastev,nmodules,option,filename);
1112
1113    static AliITSsimulationFastPoints* sim=0;
1114    if (!sim) sim = new AliITSsimulationFastPoints();
1115
1116
1117    AliITSgeom *geom = GetITSgeom();
1118
1119    Int_t id,module;
1120    for(id=0;id<3;id++) {
1121         if (!all && !det[id]) continue;
1122         Int_t first = geom->GetStartDet(id);
1123         Int_t last = geom->GetLastDet(id);
1124         for(module=first;module<=last;module++) {
1125             AliITSmodule *mod = (AliITSmodule *)fITSmodules->At(module);
1126             sim->CreateFastRecPoints(mod);
1127             gAlice->TreeR()->Fill();
1128             ResetRecPoints();
1129         } // loop over modules
1130    } // loop over detector types
1131
1132
1133    ClearModules();
1134
1135    //Int_t nentries=(Int_t)gAlice->TreeR()->GetEntries();
1136
1137    char hname[30];
1138    sprintf(hname,"TreeR%d",evNumber);
1139    gAlice->TreeR()->Write(hname);
1140    // reset tree
1141    gAlice->TreeR()->Reset();
1142
1143 }
1144
1145 //______________________________________________________________________________
1146 void AliITS::Streamer(TBuffer &R__b)
1147 {
1148    // Stream an object of class AliITS.
1149
1150   Int_t i, j, l;
1151
1152    if (R__b.IsReading()) {
1153       Version_t R__v = R__b.ReadVersion(); if (R__v) { }
1154       AliDetector::Streamer(R__b);
1155       R__b >> fITSgeom;
1156       R__b >> fITSmodules;
1157       R__b >> fEuclidOut;
1158       R__b >> fIdN;
1159       delete []fIdSens;
1160       fIdSens = new Int_t[fIdN];
1161       R__b.ReadFastArray(fIdSens,fIdN);
1162       for(i=0;i<fIdN;i++){
1163         R__b >> l;
1164         fIdName[i] = new char[l+1]; // add room for null character.
1165         for(j=0;j<l;j++) R__b >> fIdName[i][j];
1166         fIdName[i][l] = '\0'; // Null terminate this string.
1167       } // end for i
1168       //R__b.ReadArray(fIdName);
1169       R__b >> fMajorVersion;
1170       R__b >> fMinorVersion;
1171       R__b >> fDetTypes;
1172       R__b >> fNDetTypes;
1173       R__b >> fDtype;
1174       delete []fNdtype;
1175       fNdtype = new Int_t[fNDetTypes];
1176       R__b.ReadFastArray(fNdtype,fNDetTypes);
1177       R__b >> fCtype;
1178       delete []fNctype;
1179       fNctype = new Int_t[fNDetTypes];
1180       R__b.ReadFastArray(fNctype,fNDetTypes);
1181       fRecPoints->Streamer(R__b);
1182       R__b >> fNRecPoints;
1183       fTracks->Streamer(R__b);
1184       R__b >> fTreeC;
1185    } else {
1186       R__b.WriteVersion(AliITS::IsA());
1187       AliDetector::Streamer(R__b);
1188       R__b << fITSgeom;
1189       R__b << fITSmodules;
1190       R__b << fEuclidOut;
1191       R__b << fIdN;
1192       R__b.WriteFastArray(fIdSens,fIdN);
1193       for(i=0;i<fIdN;i++){
1194           l = strlen(fIdName[i]);
1195           R__b << l;
1196           for(j=0;j<l;j++) R__b << fIdName[i][j];
1197       } // end for i
1198       //R__b.WriteArray(fIdName, __COUNTER__);
1199       R__b << fMajorVersion;
1200       R__b << fMinorVersion;
1201       R__b << fDetTypes;
1202       R__b << fNDetTypes;
1203       R__b << fDtype;
1204       R__b.WriteFastArray(fNdtype,fNDetTypes);
1205       R__b << fCtype;
1206       R__b.WriteFastArray(fNctype,fNDetTypes);
1207       R__b << fRecPoints;
1208       // fRecPoints->Streamer(R__b);
1209       R__b << fNRecPoints;
1210       R__b << fTracks;
1211       //      fTracks->Streamer(R__b);
1212       R__b << fTreeC;
1213    }
1214 }
1215
1216 ClassImp(AliITSRecPoint)
1217 ClassImp(AliITSsegmentation)
1218 ClassImp(AliITSresponse)
1219 //ClassImp(AliITStrack)
1220