| bf6bf84c |
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 | // This is a TTask for reconstruction V2 in TOF |
| 18 | // Description of the algorithm |
| 19 | //-- Author: F. Pierella | pierella@bo.infn.it |
| 20 | ////////////////////////////////////////////////////////////////////////////// |
| 21 | |
| 22 | #include "TBenchmark.h" |
| 23 | #include "TFile.h" |
| 24 | #include "TFolder.h" |
| 25 | #include "TParticle.h" |
| 26 | #include "TTask.h" |
| 27 | #include "TTree.h" |
| 28 | #include "TClonesArray.h" |
| 29 | #include "TROOT.h" |
| 30 | #include "TSystem.h" |
| 31 | #include <stdlib.h> |
| 32 | #include <iostream.h> |
| 33 | #include <fstream.h> |
| b9d0a01d |
34 | #include "TGeant3.h" |
| 35 | #include "TVirtualMC.h" |
| bf6bf84c |
36 | |
| 37 | #include "AliDetector.h" |
| 38 | #include "AliMC.h" |
| 39 | #include "AliRun.h" |
| 40 | #include "AliTOF.h" |
| 41 | #include "AliTOFDigitMap.h" |
| 42 | #include "AliTOFHitMap.h" |
| 43 | #include "AliTOFhitT0.h" |
| 44 | #include "AliTOFdigit.h" |
| 45 | #include "AliTOFConstants.h" |
| 46 | #include "AliTOFReconstructionerV2.h" |
| 47 | #include "AliTOFTrackV2.h" |
| 48 | |
| b9d0a01d |
49 | #include "AliKalmanTrack.h" |
| bf6bf84c |
50 | #include "../TPC/AliTPCtrack.h" |
| 51 | #include "../TRD/AliTRDtrack.h" |
| 52 | |
| 53 | ClassImp(AliTOFReconstructionerV2) |
| 54 | |
| 55 | //____________________________________________________________________________ |
| 56 | AliTOFReconstructionerV2::AliTOFReconstructionerV2():TTask("AliTOFReconstructionerV2","") |
| 57 | { |
| 58 | // |
| 59 | // std ctor |
| 60 | // set all member vars to zero |
| 61 | // |
| 62 | fdbg =0; |
| 63 | fDigitsMap=0x0; |
| 64 | fField =0; |
| bf6bf84c |
65 | fNDummyTracks=0; |
| 66 | fScaleSigmaFactor=0.; |
| 67 | fStep =0; |
| 68 | fTOFDigits=0x0; |
| 69 | fTOFTracks=0x0; |
| 70 | fTOFDigitsFile ="digits.root"; |
| 71 | fTPCBackTracksFile="AliTPCBackTracks.root"; |
| 72 | fKalmanTree =0x0; |
| 73 | fBranchWithTracks =0x0; |
| 74 | } |
| 75 | |
| 76 | //____________________________________________________________________________ |
| 77 | AliTOFReconstructionerV2::AliTOFReconstructionerV2(char* tpcBackTracks, char* tofDigits):TTask("AliTOFReconstructionerV2","") |
| 78 | { |
| 79 | // |
| 80 | // par ctor |
| 81 | // default arguments are specified only in |
| 82 | // the header file |
| 83 | // Parameters: |
| 84 | // tpcBackTracks -> file name with backpropagated tracks in TPC |
| 85 | // tofDigits -> file name with TOF digits |
| 86 | // |
| 87 | |
| 88 | fdbg =0; |
| 89 | fDigitsMap=0x0; |
| 90 | fField =0.2; // default value 0.2 [Tesla] |
| 91 | fNDummyTracks=20; // by default 20 test tracks used |
| 92 | fScaleSigmaFactor=1.; |
| 93 | fStep =0.01; // [cm] |
| 94 | fTOFDigits=0x0; |
| 95 | fTOFTracks=0x0; |
| 96 | fTOFDigitsFile =tofDigits; |
| 97 | fTPCBackTracksFile=tpcBackTracks; |
| 98 | fKalmanTree =0x0; |
| 99 | fBranchWithTracks =0x0; |
| 100 | |
| 101 | // initialize the G3 geometry |
| 102 | gAlice->Init(); |
| 103 | gAlice->Print(); |
| bf6bf84c |
104 | |
| 105 | // add Task to //root/Tasks folder |
| 106 | TTask * roottasks = (TTask*)gROOT->GetRootFolder()->FindObject("Tasks") ; |
| 107 | roottasks->Add(this) ; |
| 108 | } |
| 109 | |
| 110 | //____________________________________________________________________________ |
| 111 | AliTOFReconstructionerV2::AliTOFReconstructionerV2(const AliTOFReconstructionerV2 & rec) |
| 112 | { |
| 113 | // |
| 114 | // Dummy copy constructor |
| 115 | // required by coding conventions |
| 116 | ; |
| 117 | } |
| 118 | |
| 119 | |
| 120 | |
| 121 | //____________________________________________________________________________ |
| 122 | AliTOFReconstructionerV2::~AliTOFReconstructionerV2() |
| 123 | { |
| 124 | // |
| 125 | // dtor |
| 126 | // some delete has to be moved |
| 127 | // |
| 128 | |
| 129 | if (fDigitsMap) |
| 130 | { |
| 131 | delete fDigitsMap; |
| 132 | fDigitsMap = 0; |
| 133 | } |
| 134 | |
| bf6bf84c |
135 | if (fTOFDigits) |
| 136 | { |
| 137 | delete fTOFDigits; |
| 138 | fTOFDigits = 0; |
| 139 | } |
| 140 | |
| 141 | if (fTOFTracks) |
| 142 | { |
| 143 | delete fTOFTracks; |
| 144 | fTOFTracks = 0; |
| 145 | } |
| 146 | |
| 147 | if (fTOFDigitsFile) |
| 148 | { |
| 149 | delete fTOFDigitsFile; |
| 150 | } |
| 151 | |
| 152 | if (fTPCBackTracksFile) |
| 153 | { |
| 154 | delete fTPCBackTracksFile; |
| 155 | } |
| 156 | |
| 157 | if (fKalmanTree) |
| 158 | { |
| 159 | delete fKalmanTree; |
| 160 | fKalmanTree = 0; |
| 161 | } |
| 162 | |
| 163 | if (fBranchWithTracks) |
| 164 | { |
| 165 | delete fBranchWithTracks; |
| 166 | fBranchWithTracks = 0; |
| 167 | } |
| 168 | } |
| 169 | |
| 170 | |
| 171 | //____________________________________________________________________________ |
| 172 | void AliTOFReconstructionerV2::Exec(Option_t* option) |
| 173 | { |
| 174 | // |
| 175 | // Description of the algorithm: |
| 176 | // |
| 177 | // |
| 178 | // |
| 179 | // |
| 180 | // |
| 181 | // |
| 182 | |
| 183 | // load TOF digits and fill the digit map |
| 184 | Int_t tofDigitsLoading=LoadTOFDigits(); |
| 185 | |
| 186 | // load back-propagated tracks in TPC |
| 187 | Int_t tpcTracksLoading=LoadTPCTracks(); |
| 188 | |
| 189 | if(tofDigitsLoading || tpcTracksLoading) { |
| 190 | cout<<" Couldn't start reconstruction V2. Exit."<<endl; |
| 191 | exit(1); |
| 192 | } |
| 193 | // or load TRD reconstructed tracks |
| 194 | // Int_t trdTracksLoading=LoadTRDTracks(); |
| 195 | |
| 196 | // create a TObjArray to store reconstructed tracks |
| 197 | // and reject fake tracks |
| 198 | const Int_t maxRecTracks = 10000; // max number of reconstructed tracks |
| 199 | // per event |
| 200 | |
| 201 | const Float_t stripRegionHeight = 15.3; // [cm] height in radial direction |
| 202 | // of the volume where strips are placed |
| 203 | TObjArray trackArray(maxRecTracks); |
| 204 | |
| 205 | // buffer for output |
| 206 | fTOFTracks= new TClonesArray("AliTOFTrackV2"); |
| 207 | // create a reference to fill the TClonesArray |
| 208 | TClonesArray &aTOFTracks = *fTOFTracks; |
| 209 | |
| 210 | const Int_t maxIndex = 100000; // max number of primary tracks to be analysed |
| 211 | // the index of the rtIndex array is the track label |
| 212 | // the content of the array is -1 for fake tracks |
| 213 | // and the track index for good tracks |
| 214 | Float_t dEdXarray[maxRecTracks]; |
| 215 | Int_t rtIndex[maxIndex]; |
| 216 | for(Int_t i = 0; i < maxIndex; i++) rtIndex[i] = -1; |
| 217 | |
| 218 | AliKalmanTrack::SetConvConst(100/0.299792458/fField); |
| 219 | |
| 220 | Int_t nRecTracks = (Int_t) fKalmanTree->GetEntries(); |
| 221 | cout<<"Found "<<nRecTracks<<" entries in the track tree "<<endl; |
| 222 | |
| 223 | // load the tracks into the array |
| 224 | for (Int_t i=0; i<nRecTracks; i++) { |
| 225 | AliTPCtrack *iotrack=new AliTPCtrack(); |
| 226 | fBranchWithTracks->SetAddress(&iotrack); |
| 227 | fKalmanTree->GetEvent(i); |
| 228 | trackArray.AddLast(iotrack); |
| 229 | Int_t trackLabel = iotrack->GetLabel(); |
| 230 | dEdXarray[i]=iotrack->GetdEdx(); // usefull for PID |
| 231 | // |
| 232 | // start filling the TClonesArray of AliTOFTrackV2 |
| 233 | Float_t trdXYZ[3]={0.,0.,0.}; |
| 234 | Float_t trdPxPyPz[3]={0.,0.,0.}; |
| 235 | |
| 236 | // tpc outer wall positions |
| 237 | Double_t xk=iotrack->GetX(); |
| 238 | // get the running coordinates in the lrf |
| 239 | // and alpha |
| 240 | Double_t x=xk; |
| 241 | Double_t y=iotrack->GetY(); |
| 242 | Double_t z=iotrack->GetZ(); |
| 243 | Double_t alpha=iotrack->GetAlpha(); |
| 244 | GetGlobalXYZ(alpha, x, y, z); |
| 245 | Float_t tpcXYZ[3]={x,y,z}; |
| 246 | |
| 247 | // momentum at the end of TPC |
| 248 | Float_t lambda=TMath::ATan(iotrack->GetTgl()); |
| 249 | Float_t invpt=TMath::Abs(iotrack->Get1Pt()); |
| 250 | Float_t pt=-99.; |
| 251 | if (invpt) pt= 1./invpt; // pt |
| 252 | Float_t tpcmom=1./(invpt*TMath::Cos(lambda)); |
| 253 | Float_t pz=tpcmom*TMath::Sin(lambda); |
| 254 | Float_t tpcPtPz[2]={pt,pz}; |
| 255 | |
| 256 | Int_t matchingStatus=-1; |
| 257 | if(trackLabel < 0) matchingStatus=0; |
| 258 | new(aTOFTracks[i]) AliTOFTrackV2(trackLabel,matchingStatus,tpcmom,dEdXarray[i],tpcXYZ,tpcPtPz,trdXYZ,trdPxPyPz); |
| 259 | // printf("rt with %d clusters and label %d \n", |
| 260 | // iotrack->GetNumberOfClusters(), trackLabel); |
| 261 | |
| 262 | if(trackLabel < 0) continue; |
| 263 | if(trackLabel >= maxIndex) continue; |
| 264 | rtIndex[trackLabel] = i; |
| 265 | delete iotrack; |
| 266 | } |
| 267 | |
| 268 | if(strstr(option,"MC")) Comparison(rtIndex); |
| 269 | |
| 270 | // start loop on tracks |
| 271 | // and backpropagate them from TPC to TOF |
| 272 | // backpropagation is performed only |
| 273 | // for good tracks (fake tracks rejected) |
| 274 | AliTPCtrack *rt; |
| 275 | |
| 276 | for (Int_t i=0; i<nRecTracks; i++) { |
| 277 | |
| 278 | //******* tracking: extract track coordinates, momentum, etc. |
| 279 | rt = (AliTPCtrack*) trackArray.UncheckedAt(i); |
| 280 | // track length to be implemented |
| 281 | // Double_t tr_length = rt->GetLength(); |
| 282 | |
| 283 | Int_t tpcTrackLabel=rt->GetLabel(); |
| 284 | // reject fake tracks |
| 285 | //if(tpcTrackLabel< 0) continue; |
| 286 | |
| 287 | // starting backpropagation to TOF |
| 288 | // here we assume to have backpropagated tracks in TPC |
| 289 | // starting point xk=246.055 |
| 290 | // starting back propagation |
| 291 | // outer wall of the TPC |
| 292 | Int_t iOuterTPCWall=rt->PropagateTo(261.53,40.,0.06124); |
| 293 | // frame with air just to the beginning of the TOF |
| 294 | Int_t iFrameWithAir=rt->PropagateTo(370.,36.66,1.2931e-3); |
| 295 | // trough the wall of the TOF plate |
| 296 | // thickness has changed according to the |
| 297 | // last value |
| 298 | Int_t iTOFWall=rt->PropagateTo(370.11,24.01,2.7); |
| 299 | |
| 300 | /* |
| 301 | // outer wall of the TPC |
| 302 | Int_t iOuterTPCWall=rt->PropagateTo(261.53,40.,0.06124); |
| 303 | // air in between TPC and TRD |
| 304 | Int_t iFrameWithAir=rt->PropagateTo(294.5,36.66,1.2931e-3); |
| 305 | // TRD itself |
| 306 | // mean density for the TRD calculated from |
| 307 | // TRD Technical Design Report |
| 308 | // page 11 -> global thickness |
| 309 | // page 23 -> different main layers thickness (Radiator Air/ Drift Chamber Gas /G10) |
| 310 | // page 139 -> material budget and radiation lengths |
| 311 | Int_t iTRD=rt->PropagateTo(369.1,171.7,0.33); |
| 312 | // air in between TRD and TOF |
| 313 | Int_t iFrameWithAirbis=rt->PropagateTo(370.,36.66,1.2931e-3); |
| 314 | // trough the wall of the TOF plate |
| 315 | Int_t iTOFWall=rt->PropagateTo(370.11,24.01,2.7); |
| 316 | */ |
| 317 | |
| 318 | // select only cases when |
| 319 | // backpropagation succeded |
| 320 | // and particle is in the geometrical TOF acceptance along Z |
| 321 | // |z|<380 [cm] |
| 322 | AliTOFTrackV2* oTOFtracks=(AliTOFTrackV2*)fTOFTracks->UncheckedAt(i); |
| 323 | Bool_t outOfZacceptance=(rt->GetZ()<=380.); |
| 324 | if(outOfZacceptance) oTOFtracks->SetMatchingStatus(-2); |
| 325 | |
| 326 | if(iOuterTPCWall==1 && iFrameWithAir==1 && iTOFWall==1 && (!outOfZacceptance)){ |
| 327 | Double_t cc[15]; |
| 328 | // get sigmaY and sigmaZ |
| 329 | rt->GetExternalCovariance(cc); |
| 330 | Double_t sigmaY =TMath::Sqrt(cc[0]); // [cm] |
| 331 | Double_t sigmaZ =TMath::Sqrt(cc[2]); // [cm] |
| 332 | |
| 333 | // arrays used by the DigitFinder |
| 334 | Int_t nSlot=1; |
| 335 | TArrayI *secArray= new TArrayI(nSlot); |
| 336 | TArrayI *plaArray= new TArrayI(nSlot); |
| 337 | TArrayI *strArray= new TArrayI(nSlot); |
| 338 | TArrayI *pdzArray= new TArrayI(nSlot); |
| 339 | TArrayI *pdxArray= new TArrayI(nSlot); |
| 340 | |
| 341 | // make fNDummyTracks clones of the current backpropagated track |
| 342 | // make a copy of the current track |
| 343 | // smear according to the backpropagated area |
| 344 | for (Int_t j=0; j<fNDummyTracks; i++) { |
| 345 | AliTPCtrack *dummyrt=new AliTPCtrack(*rt); |
| 346 | // get ylrf and zlrf |
| 347 | Double_t ylrf= dummyrt->GetY(); // P0 |
| 348 | Double_t zlrf= dummyrt->GetZ(); // P1 |
| 349 | |
| 350 | // smear according to sigmaY and sigmaZ |
| 351 | Double_t ylrfNew=gRandom->Gaus(ylrf,fScaleSigmaFactor*sigmaY); |
| 352 | Double_t zlrfNew=gRandom->Gaus(zlrf,fScaleSigmaFactor*sigmaZ); |
| 353 | |
| 354 | // set Y and Z accordingly |
| 355 | // setter to be added in the class AliTPCtrack |
| 356 | // here I have to modify the AliTPCtrack class |
| 357 | // adding the setters for Y and Z |
| 358 | //dummyrt->SetY(ylrfNew); |
| 359 | //dummyrt->SetZ(zlrfNew); |
| 360 | |
| 361 | // start fine-backpropagation inside the TOF |
| 362 | Bool_t padNotFound =kTRUE; |
| 363 | Bool_t isInStripsRegion=kTRUE; |
| 364 | Double_t xk=dummyrt->GetX(); |
| 365 | |
| 366 | while (padNotFound && isInStripsRegion){ |
| 367 | xk+=fStep; |
| 368 | // here we assume a frame with air |
| 369 | dummyrt->PropagateTo(xk,36.66,1.2931e-3); |
| 370 | // get the running coordinates in the lrf |
| 371 | // and alpha |
| 372 | Double_t x=xk; |
| 373 | Double_t y=dummyrt->GetY(); |
| 374 | Double_t z=dummyrt->GetZ(); |
| 375 | Double_t alpha=dummyrt->GetAlpha(); |
| 376 | GetGlobalXYZ(alpha, x, y, z); |
| 377 | |
| 378 | // check if the point falls into a pad |
| 379 | // using the G3 geometry |
| 380 | Int_t* volumeID = new Int_t[AliTOFConstants::fgkmaxtoftree]; |
| 381 | // volumeID[0] -> TOF Sector range [1-18] |
| 382 | // volumeID[1] -> TOF Plate range [1- 5] |
| 383 | // volumeID[2] -> TOF Strip max range [1-20] |
| 384 | // volumeID[3] -> TOF Pad along Z range [1- 2] |
| 385 | // volumeID[4] -> TOF Pad along X range [1-48] |
| 386 | |
| 387 | Float_t zInPadFrame=0.; |
| 388 | Float_t xInPadFrame=0.; |
| 389 | IsInsideThePad((Float_t)x,(Float_t)y,(Float_t)z, volumeID, zInPadFrame, xInPadFrame); |
| 390 | // adding protection versus wrong volume numbering |
| 391 | // to be released in the next release after debugging |
| 392 | if(volumeID[4]){ |
| 393 | padNotFound=kFALSE; |
| 394 | nSlot++; |
| 395 | secArray->Set(nSlot-1); |
| 396 | plaArray->Set(nSlot-1); |
| 397 | strArray->Set(nSlot-1); |
| 398 | pdzArray->Set(nSlot-1); |
| 399 | pdxArray->Set(nSlot-1); |
| 400 | |
| 401 | (*secArray)[nSlot-1]=volumeID[0]; |
| 402 | (*plaArray)[nSlot-1]=volumeID[1]; |
| 403 | (*strArray)[nSlot-1]=volumeID[2]; |
| 404 | (*pdzArray)[nSlot-1]=volumeID[3]; |
| 405 | (*pdxArray)[nSlot-1]=volumeID[4]; |
| 406 | |
| 407 | } // track falls into a pad volume |
| 408 | |
| 409 | delete [] volumeID; |
| 410 | |
| 411 | // check on xk to stop the fine-propagation |
| 412 | if(xk>=(370.+stripRegionHeight)) isInStripsRegion=kFALSE; |
| 413 | |
| 414 | } // close the while for fine-propagation |
| 415 | |
| 416 | delete dummyrt; |
| 417 | } // end loop on test tracks |
| 418 | |
| 419 | // start TOF digit finder |
| 420 | Int_t assignedVol[5]={0,0,0,0,0}; |
| 421 | Float_t tdc=-1.; |
| 422 | Int_t* digitTrackArray=0x0; |
| 423 | Bool_t assignedDigit=DigitFinder(secArray, plaArray, strArray, pdzArray, pdxArray, assignedVol, digitTrackArray, tdc); |
| 424 | |
| 425 | |
| 426 | if(assignedDigit){ |
| 427 | // fill the tree for tracks with time of flight |
| 428 | // tof is given in tdc bin |
| 429 | // conversion to [ns] |
| 430 | Float_t binWidth=50.; // [ps] |
| 431 | Float_t timeOfFlight=tdc*binWidth/1000.; |
| 432 | |
| 433 | // only the first track number contributing |
| 434 | // to the assigned digit |
| 435 | Int_t tofDigitTrackLabel=digitTrackArray[0]; |
| 436 | |
| 437 | // matching status for the current track |
| 438 | Int_t matching=4; |
| 439 | if(tpcTrackLabel==digitTrackArray[0] || tpcTrackLabel==digitTrackArray[1] || tpcTrackLabel==digitTrackArray[0]) matching=3; |
| 440 | oTOFtracks->UpdateTrack(tofDigitTrackLabel, matching, timeOfFlight); |
| 441 | } else { |
| 442 | // fill the TClonesArray for tracks with no time of flight |
| 443 | Int_t matching=1; |
| 444 | oTOFtracks->SetMatchingStatus(matching); |
| 445 | } |
| 446 | |
| 447 | // delete used memory for tmp arrays used by DigitFinder |
| 448 | delete secArray; |
| 449 | delete plaArray; |
| 450 | delete strArray; |
| 451 | delete pdzArray; |
| 452 | delete pdxArray; |
| 453 | |
| 454 | } // close the if for succeded backpropagation in TOF acceptance along z |
| 455 | |
| 456 | } // end loop on reconstructed tracks |
| 457 | |
| 458 | // free used memory for digitmap |
| 459 | delete fDigitsMap; |
| 460 | |
| 461 | // save array with TOF tracks |
| 462 | Int_t output=SaveTracks(); |
| 463 | if(output) cout << "Error writing TOF tracks " << endl; |
| 464 | } |
| 465 | |
| 466 | |
| 467 | //__________________________________________________________________ |
| 468 | void AliTOFReconstructionerV2::Init(Option_t* opt) |
| 469 | { |
| 470 | // |
| 471 | // Initialize the AliTOFReconstructionerV2 |
| 472 | // |
| 473 | // |
| 474 | } |
| 475 | |
| 476 | |
| 477 | //__________________________________________________________________ |
| 478 | Int_t AliTOFReconstructionerV2::LoadTPCTracks() |
| 479 | { |
| 480 | // |
| 481 | // Connect the tree and the branch |
| 482 | // with reconstructed tracks |
| 483 | // backpropagated in the TPC |
| 484 | |
| 485 | gBenchmark->Start("LoadTPCTracks"); |
| 486 | |
| 487 | TFile *kalFile = TFile::Open(fTPCBackTracksFile.Data()); |
| 488 | if (!kalFile->IsOpen()) {cerr<<"Can't open AliTPCBackTracks.root !\n"; return 3;} |
| 489 | |
| 490 | // tracks from Kalman |
| 491 | Int_t event=0; |
| 492 | char treename[100]; sprintf(treename,"TreeT_TPCb_%d",event); |
| 493 | fKalmanTree=(TTree*)kalFile->Get(treename); |
| 494 | if (!fKalmanTree) {cerr<<"Can't get a tree with TPC back tracks !\n"; return 4;} |
| 495 | |
| 496 | // otherwise you get always 0 for 1/pt |
| 497 | AliKalmanTrack::SetConvConst(100/0.299792458/fField); |
| 498 | |
| 499 | fBranchWithTracks=fKalmanTree->GetBranch("tracks"); |
| 500 | Int_t kalEntries =(Int_t)fKalmanTree->GetEntries(); |
| 501 | cout<<"Number of loaded Tracks :"<< kalEntries <<endl; |
| 502 | |
| 503 | gBenchmark->Stop("LoadTPCTracks"); |
| 504 | gBenchmark->Show("LoadTPCTracks"); |
| 505 | return 0; |
| 506 | } |
| 507 | |
| 508 | //__________________________________________________________________ |
| 509 | Int_t AliTOFReconstructionerV2::LoadTRDTracks() |
| 510 | { |
| 511 | // |
| 512 | // Connect the tree and the branch |
| 513 | // with reconstructed tracks in TRD |
| 514 | |
| 515 | gBenchmark->Start("LoadTRDTracks"); |
| 516 | |
| 517 | Int_t nEvent = 0; |
| 518 | const Int_t nPrimaries = 84210/16; |
| 519 | const Int_t maxIndex = nPrimaries; |
| 520 | Int_t rtIndex[maxIndex]; |
| 521 | |
| 522 | TFile *tf=TFile::Open("AliTRDtracks.root"); |
| 523 | |
| 524 | if (!tf->IsOpen()) {cerr<<"Can't open AliTRDtracks.root !\n"; return 3;} |
| 525 | TObjArray tarray(2000); |
| 526 | char tname[100]; |
| 527 | sprintf(tname,"TRDb_%d",nEvent); |
| 528 | TTree *tracktree=(TTree*)tf->Get(tname); |
| 529 | |
| 530 | TBranch *tbranch=tracktree->GetBranch("tracks"); |
| 531 | |
| 532 | Int_t nRecTracks = (Int_t) tracktree->GetEntries(); |
| 533 | cerr<<"Found "<<nRecTracks<<" entries in the track tree"<<endl; |
| 534 | |
| 535 | for (Int_t i=0; i<nRecTracks; i++) { |
| 536 | AliTRDtrack *iotrack=new AliTRDtrack(); |
| 537 | tbranch->SetAddress(&iotrack); |
| 538 | tracktree->GetEvent(i); |
| 539 | tarray.AddLast(iotrack); |
| 540 | Int_t trackLabel = iotrack->GetLabel(); |
| 541 | |
| 542 | // printf("rt with %d clusters and label %d \n", |
| 543 | // iotrack->GetNumberOfClusters(), trackLabel); |
| 544 | |
| 545 | if(trackLabel < 0) continue; |
| 546 | if(trackLabel >= maxIndex) continue; |
| 547 | rtIndex[trackLabel] = i; |
| 548 | } |
| 549 | tf->Close(); |
| 550 | gBenchmark->Stop("LoadTRDTracks"); |
| 551 | gBenchmark->Show("LoadTRDTracks"); |
| 552 | return 0; |
| 553 | |
| 554 | } |
| 555 | |
| 556 | //__________________________________________________________________ |
| 557 | Int_t AliTOFReconstructionerV2::LoadTOFDigits() |
| 558 | { |
| 559 | // |
| 560 | // Connect the TClonesArray with TOF |
| 561 | // digits and fill the digit map |
| 562 | // used by the DigitFinder |
| 563 | |
| 564 | Int_t rc=0; |
| 565 | |
| 566 | gBenchmark->Start("LoadTOFDigits"); |
| 567 | |
| 568 | TFile *file = (TFile*)gROOT->GetListOfFiles()->FindObject(fTOFDigitsFile.Data()); |
| 569 | if(file){ |
| 570 | cout<<"headerFile already open \n"; |
| 571 | } |
| 572 | else { |
| 573 | if(!file)file=TFile::Open(fTOFDigitsFile.Data()); |
| 574 | } |
| 575 | |
| 576 | // Get AliRun object from file |
| 577 | if (!gAlice) { |
| 578 | gAlice = (AliRun*)file->Get("gAlice"); |
| 579 | if (gAlice) printf("AliRun object found on file\n"); |
| 580 | } |
| 581 | |
| 582 | Int_t iEvNum = 0; |
| 583 | if (iEvNum == 0) iEvNum = (Int_t) gAlice->TreeE()->GetEntries(); |
| 584 | |
| 585 | |
| 586 | AliTOFdigit *tofdigit; |
| 587 | |
| 588 | AliTOF * tof = (AliTOF *) gAlice->GetDetector("TOF") ; |
| 589 | |
| 590 | if (!tof) { |
| 591 | cout << "<LoadTOFDigits> No TOF detector found" << endl; |
| 592 | rc = 2; |
| 593 | return rc; |
| 594 | } |
| 595 | |
| 596 | for (Int_t ievent = 0; ievent < iEvNum; ievent++) { |
| 597 | |
| 598 | gAlice->GetEvent(ievent) ; |
| 599 | if(gAlice->TreeD()==0) { |
| 600 | cout << "<LoadTOFDigits> No TreeD found" << endl; |
| 601 | rc = 4; |
| 602 | return rc; |
| 603 | } |
| 604 | |
| 605 | |
| 606 | Int_t ndig; |
| 607 | gAlice->ResetDigits(); |
| 608 | gAlice->TreeD()->GetEvent(ievent); |
| 609 | fTOFDigits = tof->Digits(); |
| 610 | |
| 611 | ndig=fTOFDigits->GetEntries(); |
| 612 | |
| 613 | // create the digit map |
| 614 | fDigitsMap = new AliTOFDigitMap(fTOFDigits); |
| 615 | |
| 616 | |
| 617 | cout << "<LoadTOFDigits> found " << ndig |
| 618 | << " TOF digits for event " << ievent << endl; |
| 619 | |
| 620 | for (Int_t k=0; k<ndig; k++) { |
| 621 | tofdigit= (AliTOFdigit*) fTOFDigits->UncheckedAt(k); |
| 622 | Float_t tdc=tofdigit->GetTdc(); |
| 623 | // adc value can be used for weighting |
| 624 | //Float_t adc=tofdigit->GetAdc(); |
| 625 | |
| 626 | // TOF digit volumes |
| 627 | Int_t vol[5]; // location for a digit |
| 628 | Int_t sector = tofdigit->GetSector(); // range [1-18] |
| 629 | Int_t plate = tofdigit->GetPlate(); // range [1- 5] |
| 630 | Int_t strip = tofdigit->GetStrip(); // range [1-20] |
| 631 | Int_t padx = tofdigit->GetPadx(); // range [1-48] |
| 632 | Int_t padz = tofdigit->GetPadz(); // range [1- 2] |
| 633 | |
| 634 | vol[0] = sector; |
| 635 | vol[1] = plate; |
| 636 | vol[2] = strip; |
| 637 | vol[3] = padx; |
| 638 | vol[4] = padz; |
| 639 | |
| 640 | // QA |
| 641 | Bool_t isDigitBad = (sector<1 || sector>18 || plate<1 || plate >5 || padz<1 || padz>2 || padx<1 || padx>48); |
| 642 | |
| 643 | if (isDigitBad) { |
| 644 | cout << "<LoadTOFDigits> strange digit found" << endl; |
| 645 | rc = 3; |
| 646 | return rc; |
| 647 | } // if (isDigitBad) |
| 648 | |
| 649 | // Fill the digit map checking if the location is already used |
| 650 | // in this case we take the earliest signal |
| 651 | if (fDigitsMap->TestHit(vol) != kEmpty) { |
| 652 | // start comparison in between the 2 digit |
| 653 | AliTOFdigit *dig = static_cast<AliTOFdigit*>(fDigitsMap->GetHit(vol)); |
| 654 | if(tdc < (dig->GetTdc())) fDigitsMap->SetHit(vol,k); |
| 655 | // we can add also the check on adc value |
| 656 | // by selecting the largest adc value |
| 657 | } else { |
| 658 | fDigitsMap->SetHit(vol,k); |
| 659 | } |
| 660 | // to be added protection versus 2-digit on the same pad |
| 661 | // we have to have memory also of the second digit |
| 662 | |
| 663 | } // for (k=0; k<ndig; k++) |
| 664 | |
| 665 | } // end loop on events |
| 666 | |
| 667 | gBenchmark->Stop("LoadTOFDigits"); |
| 668 | gBenchmark->Show("LoadTOFDigits"); |
| 669 | return rc; |
| 670 | } |
| 671 | |
| 672 | //__________________________________________________________________ |
| 673 | void AliTOFReconstructionerV2::IsInsideThePad(Float_t x, Float_t y, Float_t z, Int_t *nGeom, Float_t& zPad, Float_t& xPad) |
| 674 | { |
| 675 | // input: x,y,z - coordinates of a point in the mrf [cm] |
| 676 | // output: array nGeom[] |
| 677 | // nGeom[0] - the TOF sector number, 1,2,...,18 along azimuthal direction starting from -90 deg. |
| 678 | // nGeom[1] - the TOF module number, 1,2,3,4,5=C,B,A,B,C along z-direction |
| 679 | // nGeom[2] - the TOF strip number, 1,2,... along z-direction |
| 680 | // nGeom[3] - the TOF padz number, 1,2=NPZ across a strip |
| 681 | // nGeom[4] - the TOF padx number, 1,2,...,48=NPX along a strip |
| 682 | // zPad, xPad - coordinates of the hit in the pad frame |
| 683 | // numbering is adopted for the version 3.08 of AliRoot |
| 684 | // example: |
| 685 | // from Hits: sec,pla,str,padz,padx=4,2,14,2,35 |
| 686 | // Vol. n.0: ALIC, copy number 1 |
| 687 | // Vol. n.1: B077, copy number 1 |
| 688 | // Vol. n.2: B074, copy number 5 |
| 689 | // Vol. n.3: BTO2, copy number 1 |
| 690 | // Vol. n.4: FTOB, copy number 2 |
| 691 | // Vol. n.5: FLTB, copy number 0 |
| 692 | // Vol. n.6: FSTR, copy number 14 |
| 693 | // Vol. n.7: FSEN, copy number 0 |
| 694 | // Vol. n.8: FSEZ, copy number 2 |
| 695 | // Vol. n.9: FSEX, copy number 35 |
| 696 | // Vol. n.10: FPAD, copy number 0 |
| 697 | |
| 698 | |
| 699 | Float_t xTOF[3]; |
| 700 | Int_t sector=0,module=0,strip=0,padz=0,padx=0; |
| 701 | Int_t i,numed,nLevel,copyNumber; |
| 702 | Gcvolu_t* gcvolu; |
| 703 | char name[5]; |
| 704 | name[4]=0; |
| 705 | |
| 706 | for (i=0; i<AliTOFConstants::fgkmaxtoftree; i++) nGeom[i]=0; |
| 707 | zPad=100.; |
| 708 | xPad=100.; |
| 709 | |
| 710 | xTOF[0]=x; |
| 711 | xTOF[1]=y; |
| 712 | xTOF[2]=z; |
| 713 | |
| b9d0a01d |
714 | TGeant3 * fG3Geom = (TGeant3*) gMC; |
| 715 | |
| bf6bf84c |
716 | fG3Geom->Gmedia(xTOF, numed); |
| 717 | gcvolu=fG3Geom->Gcvolu(); |
| 718 | nLevel=gcvolu->nlevel; |
| 719 | if(fdbg) { |
| 720 | for (Int_t i=0; i<nLevel; i++) { |
| 721 | strncpy(name,(char*) (&gcvolu->names[i]),4); |
| 722 | cout<<"Vol. n."<<i<<": "<<name<<", copy number "<<gcvolu->number[i]<<endl; |
| 723 | } |
| 724 | } |
| 725 | if(nLevel>=2) { |
| 726 | // sector type name: B071(1,2,...,10),B074(1,2,3,4,5-PHOS),B075(1,2,3-RICH) |
| 727 | strncpy(name,(char*) (&gcvolu->names[2]),4); |
| 728 | // volume copy: 1,2,...,10 for B071, 1,2,3,4,5 for B074, 1,2,3 for B075 |
| 729 | copyNumber=gcvolu->number[2]; |
| 730 | if(!strcmp(name,"B071")) { |
| 731 | if (copyNumber>=6 && copyNumber<=8) { |
| 732 | sector=copyNumber+10; |
| 733 | } else if (copyNumber>=1 && copyNumber<=5){ |
| 734 | sector=copyNumber+7; |
| 735 | } else { |
| 736 | sector=copyNumber-8; |
| 737 | } |
| 738 | } else if(!strcmp(name,"B075")) { |
| 739 | sector=copyNumber+12; |
| 740 | } else if(!strcmp(name,"B074")) { |
| 741 | if (copyNumber>=1 && copyNumber<=3){ |
| 742 | sector=copyNumber+4; |
| 743 | } else { |
| 744 | sector=copyNumber-1; |
| 745 | } |
| 746 | } |
| 747 | } |
| 748 | if(sector) { |
| 749 | nGeom[0]=sector; |
| 750 | if(nLevel>=4) { |
| 751 | // we'll use the module value in z-direction: |
| 752 | // 1 2 3 4 5 |
| 753 | // the module order in z-direction: FTOC,FTOB,FTOA,FTOB,FTOC |
| 754 | // the module copy: 2 2 0 1 1 |
| 755 | // module type name: FTOA, FTOB, FTOC |
| 756 | strncpy(name,(char*) (&gcvolu->names[4]),4); |
| 757 | // module copy: |
| 758 | copyNumber=gcvolu->number[4]; |
| 759 | if(!strcmp(name,"FTOC")) { |
| 760 | if (copyNumber==2) { |
| 761 | module=1; |
| 762 | } else { |
| 763 | module=5; |
| 764 | } |
| 765 | } else if(!strcmp(name,"FTOB")) { |
| 766 | if (copyNumber==2) { |
| 767 | module=2; |
| 768 | } else { |
| 769 | module=4; |
| 770 | } |
| 771 | } else if(!strcmp(name,"FTOA")) { |
| 772 | module=3; |
| 773 | } |
| 774 | } |
| 775 | } |
| 776 | |
| 777 | if(module) { |
| 778 | nGeom[1]=module; |
| 779 | if(nLevel>=6) { |
| 780 | // strip type name: FSTR |
| 781 | strncpy(name,(char*) (&gcvolu->names[6]),4); |
| 782 | // strip copy: |
| 783 | copyNumber=gcvolu->number[6]; |
| 784 | if(!strcmp(name,"FSTR")) strip=copyNumber; |
| 785 | } |
| 786 | } |
| 787 | |
| 788 | if(strip) { |
| 789 | nGeom[2]=strip; |
| 790 | if(nLevel>=8) { |
| 791 | // padz type name: FSEZ |
| 792 | strncpy(name,(char*) (&gcvolu->names[8]),4); |
| 793 | // padz copy: |
| 794 | copyNumber=gcvolu->number[8]; |
| 795 | if(!strcmp(name,"FSEZ")) padz=copyNumber; |
| 796 | } |
| 797 | } |
| 798 | if(padz) { |
| 799 | nGeom[3]=padz; |
| 800 | if(nLevel>=9) { |
| 801 | // padx type name: FSEX |
| 802 | strncpy(name,(char*) (&gcvolu->names[9]),4); |
| 803 | // padx copy: |
| 804 | copyNumber=gcvolu->number[9]; |
| 805 | if(!strcmp(name,"FSEX")) padx=copyNumber; |
| 806 | } |
| 807 | } |
| 808 | |
| 809 | if(padx) { |
| 810 | nGeom[4]=padx; |
| 811 | zPad=gcvolu->glx[2]; |
| 812 | xPad=gcvolu->glx[0]; |
| 813 | } |
| 814 | |
| 815 | } |
| 816 | |
| 817 | //__________________________________________________________________ |
| 818 | void AliTOFReconstructionerV2::GetGlobalXYZ(Double_t alpha, Double_t& x, Double_t& y, Double_t& z) |
| 819 | { |
| 820 | // |
| 821 | // return the current running coordinates of |
| 822 | // the track in the global reference frame |
| 823 | // x, y and z have to initialized to the |
| 824 | // local frame coordinates by the caller |
| 825 | // alpha is the alpha coordinate in the TPC Kalman |
| 826 | // reference frame |
| 827 | |
| 828 | // it take into account differences in between |
| 829 | // TPC and TRD local coordinates frames |
| 830 | if (alpha < -TMath::Pi()) alpha += 2*TMath::Pi(); |
| 831 | else if (alpha >= TMath::Pi()) alpha -= 2*TMath::Pi(); |
| 832 | |
| 833 | // conversion |
| 834 | Double_t tmp=x*TMath::Cos(alpha) - y*TMath::Sin(alpha); |
| 835 | y=x*TMath::Sin(alpha) + y*TMath::Cos(alpha); |
| 836 | x=tmp; |
| 837 | } |
| 838 | |
| 839 | //__________________________________________________________________ |
| 840 | Bool_t AliTOFReconstructionerV2::DigitFinder(TArrayI *secArray, TArrayI *plaArray, TArrayI *strArray, TArrayI *pdzArray, TArrayI *pdxArray, Int_t* assignedVol, Int_t* digitTrackArray, Float_t& tdc) |
| 841 | { |
| 842 | // |
| 843 | // Description |
| 844 | // input: arrays with sectors, plates, strips, padz, padx |
| 845 | // found during fine-propagation of probe tracks |
| 846 | // |
| 847 | // output kFALSE if signal is not found |
| 848 | // kTRUE if signal is found |
| 849 | // in this case the assignedVol array contains the digit volume numbers |
| 850 | // and digitTrackArray the track numbers (max 3) contributing to the |
| 851 | // digit |
| 852 | |
| 853 | Bool_t dummy=kFALSE; |
| 854 | Int_t nFilledSlot=secArray->GetSize(); |
| 855 | |
| 856 | // start loop |
| 857 | Float_t maxWeight=-1.; |
| 858 | Int_t indexOfMaxWeight=-1; |
| 859 | for (Int_t i = 0; i < nFilledSlot; i++) { |
| 860 | Int_t vol[5]; // location for a digit |
| 861 | vol[0] = (*secArray)[i]; |
| 862 | vol[1] = (*plaArray)[i]; |
| 863 | vol[2] = (*strArray)[i]; |
| 864 | vol[3] = (*pdxArray)[i]; |
| 865 | vol[4] = (*pdzArray)[i]; |
| 866 | |
| 867 | // check for digit in the current location |
| 868 | if (fDigitsMap->TestHit(vol) != kEmpty) { |
| 869 | |
| 870 | AliTOFdigit *dig = static_cast<AliTOFdigit*>(fDigitsMap->GetHit(vol)); |
| 871 | Float_t adcWeight=dig->GetAdc(); |
| 872 | if(adcWeight > maxWeight){ |
| 873 | maxWeight=adcWeight; |
| 874 | indexOfMaxWeight=i; |
| 875 | tdc=dig->GetTdc(); |
| 876 | digitTrackArray=dig->GetTracks(); |
| 877 | |
| 878 | } // if(adcWeight > maxWeight) |
| 879 | } // close if (fDigitsMap->TestHit(vol) != kEmpty) |
| 880 | |
| 881 | } // end loop |
| 882 | |
| 883 | if(indexOfMaxWeight!=-1){ |
| 884 | assignedVol[0]=(*secArray)[indexOfMaxWeight]; |
| 885 | assignedVol[1]=(*plaArray)[indexOfMaxWeight]; |
| 886 | assignedVol[2]=(*strArray)[indexOfMaxWeight]; |
| 887 | assignedVol[3]=(*pdxArray)[indexOfMaxWeight]; |
| 888 | assignedVol[4]=(*pdzArray)[indexOfMaxWeight]; |
| 889 | dummy=kTRUE; |
| 890 | } |
| 891 | |
| 892 | return dummy; |
| 893 | } |
| 894 | |
| 895 | //__________________________________________________________________ |
| 896 | Int_t AliTOFReconstructionerV2::SaveTracks(const Char_t *outname, const Int_t split) |
| 897 | { |
| 898 | // |
| 899 | // save reconstructed tracks into |
| 900 | // outname file |
| 901 | // |
| 902 | TDirectory *savedir=gDirectory; |
| 903 | const Char_t *name="Writing Output"; |
| 904 | cerr<<'\n'<<name<<"...\n"; |
| 905 | gBenchmark->Start(name); |
| 906 | |
| 907 | TFile *out=TFile::Open(outname,"RECREATE"); |
| 908 | if (!out->IsOpen()) { |
| 909 | cerr<<"AliTOFReconstructionerV2::SaveTracks(): "; |
| 910 | cerr<<"file for TOF tracks is not open !\n"; |
| 911 | return 2; |
| 912 | } |
| 913 | |
| 914 | out->cd(); |
| 915 | TTree T("T","tree with TOF tracks"); |
| 916 | T.Branch("tracks",&fTOFTracks,256000,split); |
| 917 | |
| 918 | |
| 919 | T.Fill(); |
| 920 | T.Write(); |
| 921 | savedir->cd(); |
| 922 | out->Close(); |
| 923 | return 0; |
| 924 | gBenchmark->Stop(name); |
| 925 | gBenchmark->Show(name); |
| 926 | } |
| 927 | |
| 928 | //__________________________________________________________________ |
| 929 | void AliTOFReconstructionerV2::Comparison(Int_t* rtIndex) |
| 930 | { |
| 931 | // |
| 932 | // perform MC comparison |
| 933 | // used also for track length |
| 934 | // for the time being |
| 935 | // Connect the AliRoot file containing Geometry, Kine, Hits, and Digits |
| 936 | |
| 937 | |
| 938 | Int_t nEvent = 0; |
| 939 | Char_t *alifile = "galice.root"; |
| 940 | |
| 941 | TFile *gafl = (TFile*) gROOT->GetListOfFiles()->FindObject(alifile); |
| 942 | if (!gafl) { |
| 943 | cout << "Open the ALIROOT-file " << alifile << endl; |
| 944 | gafl = new TFile(alifile); |
| 945 | } |
| 946 | else { |
| 947 | cout << alifile << " is already open" << endl; |
| 948 | } |
| 949 | |
| 950 | // Get AliRun object from file or create it if not on file |
| 951 | gAlice = (AliRun*) gafl->Get("gAlice"); |
| 952 | if (gAlice) |
| 953 | cout << "AliRun object found on file" << endl; |
| 954 | else |
| 955 | gAlice = new AliRun("gAlice","Alice test program"); |
| 956 | |
| 957 | |
| 958 | // Import the Trees for the event nEvent in the file |
| 959 | const Int_t nparticles = gAlice->GetEvent(nEvent); |
| 960 | if (nparticles <= 0) return; |
| 961 | |
| 962 | // Get pointers to Alice detectors and Hits containers |
| 963 | AliDetector *TOF = gAlice->GetDetector("TOF"); |
| 964 | Int_t ntracks = (Int_t) gAlice->TreeH()->GetEntries(); |
| 965 | |
| 966 | // Start loop on tracks in the hits containers |
| 967 | for (Int_t track=0; track < ntracks; track++) { |
| 968 | |
| 969 | if(TOF) { |
| 970 | for(AliTOFhitT0* tofHit = (AliTOFhitT0*)TOF->FirstHit(track); |
| 971 | tofHit; |
| 972 | tofHit=(AliTOFhitT0*)TOF->NextHit()) { |
| 973 | |
| 974 | Int_t ipart = tofHit->GetTrack(); |
| 975 | if(ipart >= 80000) continue; |
| 976 | if(rtIndex[ipart] < 0) continue; |
| 977 | |
| 978 | TParticle *part = gAlice->Particle(ipart); |
| 979 | |
| 980 | // get first the pdg code |
| 981 | Int_t pdgCode=part->GetPdgCode(); |
| 982 | |
| 983 | // then track length |
| 984 | Float_t trackLength=tofHit->GetLen(); // [cm] |
| 985 | |
| 986 | // update the tof TClonesArray with TOF tracks |
| 987 | AliTOFTrackV2* oTOFtracks=(AliTOFTrackV2*)fTOFTracks->UncheckedAt(rtIndex[ipart]); |
| 988 | oTOFtracks->UpdateTrack(pdgCode,trackLength); |
| 989 | |
| 990 | } // loop on hits connected to the current track |
| 991 | } // if(TOF) |
| 992 | } // end loop on primary tracks |
| 993 | } |
| 0085f44e |
994 | |
| 995 | //__________________________________________________________________ |
| 996 | Bool_t AliTOFReconstructionerV2::operator==(const AliTOFReconstructionerV2 & tofrecv2)const |
| 997 | { |
| 998 | // Equal operator. |
| 999 | // Reconstructioner are equal if their fField, fNDummyTracks, fScaleSigmaFactor and fStep are equal |
| 1000 | |
| 1001 | if( (fField==tofrecv2.fField)&&(fNDummyTracks==tofrecv2.fNDummyTracks)&&(fScaleSigmaFactor==tofrecv2.fScaleSigmaFactor)&&(fStep==tofrecv2.fStep)) |
| 1002 | return kTRUE ; |
| 1003 | else |
| 1004 | return kFALSE ; |
| 1005 | } |
git://git.uio.no / u / mrichter / AliRoot.git / blame