STEER/AOD/AliAODHeader.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-2007, 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 //     AOD event base class
  20 //     Author: Markus Oldenburg, CERN
  21 //-------------------------------------------------------------------------
  22
  23 #include "AliAODHeader.h"
  24 #include "AliCentrality.h"
  25 #include "AliEventplane.h"
  26 #include <TGeoMatrix.h>
  27 #include <TObjString.h>
  28
  29 ClassImp(AliAODHeader)
  30
  31 //______________________________________________________________________________
  32 AliAODHeader::AliAODHeader() :
  33   AliVHeader(),
  34   fMagneticField(-999.),
  35   fMuonMagFieldScale(-999.),
  36   fCentrality(-999.),
  37   fEventplane(-999.),
  38   fEventplaneMag(-999.),
  39   fEventplaneQx(-999.),
  40   fEventplaneQy(-999.),
  41   fZDCN1Energy(-999.),
  42   fZDCP1Energy(-999.),
  43   fZDCN2Energy(-999.),
  44   fZDCP2Energy(-999.),
  45   fNQTheta(0),
  46   fQTheta(0x0),
  47   fTriggerMask(0),
  48   fFiredTriggers(),
  49   fRunNumber(-999),
  50   fRefMult(-999),
  51   fRefMultPos(-999),
  52   fRefMultNeg(-999),
  53   fNMuons(0),
  54   fNDimuons(0),
  55   fEventType(0),
  56   fOrbitNumber(0),
  57   fPeriodNumber(0),
  58   fBunchCrossNumber(0),
  59   fRefMultComb05(-999),
  60   fRefMultComb08(-999),
  61   fTriggerCluster(0),
  62   fDiamondZ(0.),
  63   fDiamondSig2Z(0.),
  64   fOfflineTrigger(0),
  65   fESDFileName(""),
  66   fEventNumberESDFile(-1),
  67   fL0TriggerInputs(0),
  68   fL1TriggerInputs(0),
  69   fL2TriggerInputs(0),
  70   fTPConlyRefMult(-1),
  71   fCentralityP(0),
  72   fEventplaneP(0),
  73   fIRInt2InteractionsMap(0),
  74   fIRInt1InteractionsMap(0)
  75 {
  76   // default constructor
  77
  78   SetName("header");
  79   for(int j=0; j<2; j++) fZDCEMEnergy[j] = -999.;
  80   for(Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
  81   fDiamondCovXY[0]=fDiamondCovXY[2]=3.*3.;
  82   fDiamondCovXY[1]=0.;
  83   for (Int_t m=0; m<kNPHOSMatrix; m++) fPHOSMatrix[m]=NULL;
  84   for (Int_t sm=0; sm<kNEMCALMatrix; sm++) fEMCALMatrix[sm]=NULL;
  85   for (Int_t i = 0; i < 6; i++)  fITSClusters[i] = 0;
  86   for (Int_t j=0; j<64; ++j) fVZEROEqFactors[j]=-1;
  87   for (Int_t i=0; i<kT0SpreadSize;i++) fT0spread[i]=0;
  88 }
  89
  90 //______________________________________________________________________________
  91 AliAODHeader::AliAODHeader(Int_t nRun,
  92                            UShort_t nBunchX,
  93                            UInt_t nOrbit,
  94                            UInt_t nPeriod,
  95                            const Char_t *title) :
  96   AliVHeader(),
  97   fMagneticField(-999.),
  98   fMuonMagFieldScale(-999.),
  99   fCentrality(-999.),
 100   fEventplane(-999.),
 101   fEventplaneMag(-999.),
 102   fEventplaneQx(-999.),
 103   fEventplaneQy(-999.),
 104   fZDCN1Energy(-999.),
 105   fZDCP1Energy(-999.),
 106   fZDCN2Energy(-999.),
 107   fZDCP2Energy(-999.),
 108   fNQTheta(0),
 109   fQTheta(0x0),
 110   fTriggerMask(0),
 111   fFiredTriggers(),
 112   fRunNumber(nRun),
 113   fRefMult(-999),
 114   fRefMultPos(-999),
 115   fRefMultNeg(-999),
 116   fNMuons(0),
 117   fNDimuons(0),
 118   fEventType(0),
 119   fOrbitNumber(nOrbit),
 120   fPeriodNumber(nPeriod),
 121   fBunchCrossNumber(nBunchX),
 122   fRefMultComb05(-999),
 123   fRefMultComb08(-999),
 124   fTriggerCluster(0),
 125   fDiamondZ(0.),
 126   fDiamondSig2Z(0.),
 127   fOfflineTrigger(0),
 128   fESDFileName(""),
 129   fEventNumberESDFile(-1),
 130   fL0TriggerInputs(0),
 131   fL1TriggerInputs(0),
 132   fL2TriggerInputs(0),
 133   fTPConlyRefMult(-1),
 134   fCentralityP(0),
 135   fEventplaneP(0),
 136   fIRInt2InteractionsMap(0),
 137   fIRInt1InteractionsMap(0)
 138 {
 139   // constructor
 140
 141   SetName("header");
 142   SetTitle(title);
 143   for(int j=0; j<2; j++) fZDCEMEnergy[j] = -999.;
 144   for(Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
 145   fDiamondCovXY[0]=fDiamondCovXY[2]=3.*3.;
 146   fDiamondCovXY[1]=0.;
 147   for (Int_t m=0; m<kNPHOSMatrix; m++) fPHOSMatrix[m]=NULL;
 148   for (Int_t sm=0; sm<kNEMCALMatrix; sm++) fEMCALMatrix[sm]=NULL;
 149   for (Int_t j=0; j<64; ++j) fVZEROEqFactors[j]=-1;
 150   for (Int_t i=0; i<kT0SpreadSize;i++) fT0spread[i]=0;
 151 }
 152
 153 //______________________________________________________________________________
 154 AliAODHeader::AliAODHeader(Int_t nRun,
 155                            UShort_t nBunchX,
 156                            UInt_t nOrbit,
 157                            UInt_t nPeriod,
 158                            Int_t refMult,
 159                            Int_t refMultPos,
 160                            Int_t refMultNeg,
 161                            Int_t refMultComb05,
 162                            Int_t refMultComb08,
 163                            Double_t magField,
 164                            Double_t muonMagFieldScale,
 165                            Double_t cent,
 166                            Double_t eventplane,
 167                            Double_t n1Energy,
 168                            Double_t p1Energy,
 169                            Double_t n2Energy,
 170                            Double_t p2Energy,
 171                            Double_t *emEnergy,
 172                            ULong64_t trigMask,
 173                            UChar_t trigClus,
 174                            UInt_t evttype,
 175                            const Float_t *vzeroEqFactors,
 176                            const Char_t *title,
 177                            Int_t nMuons,
 178                            Int_t nDimuons) :
 179   AliVHeader(),
 180   fMagneticField(magField),
 181   fMuonMagFieldScale(muonMagFieldScale),
 182   fCentrality(cent),
 183   fEventplane(eventplane),
 184   fEventplaneMag(0),
 185   fEventplaneQx(0),
 186   fEventplaneQy(0),
 187   fZDCN1Energy(n1Energy),
 188   fZDCP1Energy(p1Energy),
 189   fZDCN2Energy(n2Energy),
 190   fZDCP2Energy(p2Energy),
 191   fNQTheta(0),
 192   fQTheta(0x0),
 193   fTriggerMask(trigMask),
 194   fFiredTriggers(),
 195   fRunNumber(nRun),
 196   fRefMult(refMult),
 197   fRefMultPos(refMultPos),
 198   fRefMultNeg(refMultNeg),
 199   fNMuons(nMuons),
 200   fNDimuons(nDimuons),
 201   fEventType(evttype),
 202   fOrbitNumber(nOrbit),
 203   fPeriodNumber(nPeriod),
 204   fBunchCrossNumber(nBunchX),
 205   fRefMultComb05(refMultComb05),
 206   fRefMultComb08(refMultComb08),
 207   fTriggerCluster(trigClus),
 208   fDiamondZ(0.),
 209   fDiamondSig2Z(0.),
 210   fOfflineTrigger(0),
 211   fESDFileName(""),
 212   fEventNumberESDFile(-1),
 213   fL0TriggerInputs(0),
 214   fL1TriggerInputs(0),
 215   fL2TriggerInputs(0),
 216   fTPConlyRefMult(-1),
 217   fCentralityP(0),
 218   fEventplaneP(0),
 219   fIRInt2InteractionsMap(0),
 220   fIRInt1InteractionsMap(0)
 221 {
 222   // constructor
 223
 224   SetName("header");
 225   SetTitle(title);
 226   for(int j=0; j<2; j++) fZDCEMEnergy[j] = emEnergy[j];
 227   for(Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
 228   fDiamondCovXY[0]=fDiamondCovXY[2]=3.*3.;
 229   fDiamondCovXY[1]=0.;
 230   for (Int_t m=0; m<kNPHOSMatrix; m++) fPHOSMatrix[m]=NULL;
 231   for (Int_t sm=0; sm<kNEMCALMatrix; sm++) fEMCALMatrix[sm]=NULL;
 232   for (Int_t i = 0; i < 6; i++)  fITSClusters[i] = 0;
 233   if (vzeroEqFactors) for (Int_t j=0; j<64; ++j) fVZEROEqFactors[j] = vzeroEqFactors[j];
 234   for (Int_t i=0; i<kT0SpreadSize;i++) fT0spread[i]=0;
 235 }
 236
 237 //______________________________________________________________________________
 238 AliAODHeader::~AliAODHeader()
 239 {
 240   // destructor
 241   delete fCentralityP;
 242   delete fEventplaneP;
 243   RemoveQTheta();
 244 }
 245
 246 //______________________________________________________________________________
 247 AliAODHeader::AliAODHeader(const AliAODHeader& hdr) :
 248   AliVHeader(hdr),
 249   fMagneticField(hdr.fMagneticField),
 250   fMuonMagFieldScale(hdr.fMuonMagFieldScale),
 251   fCentrality(hdr.fCentrality),
 252   fEventplane(hdr.fEventplane),
 253   fEventplaneMag(hdr.fEventplaneMag),
 254   fEventplaneQx(hdr.fEventplaneQx),
 255   fEventplaneQy(hdr.fEventplaneQy),
 256   fZDCN1Energy(hdr.fZDCN1Energy),
 257   fZDCP1Energy(hdr.fZDCP1Energy),
 258   fZDCN2Energy(hdr.fZDCN2Energy),
 259   fZDCP2Energy(hdr.fZDCP2Energy),
 260   fNQTheta(0),
 261   fQTheta(0x0),
 262   fTriggerMask(hdr.fTriggerMask),
 263   fFiredTriggers(hdr.fFiredTriggers),
 264   fRunNumber(hdr.fRunNumber),
 265   fRefMult(hdr.fRefMult),
 266   fRefMultPos(hdr.fRefMultPos),
 267   fRefMultNeg(hdr.fRefMultNeg),
 268   fNMuons(hdr.fNMuons),
 269   fNDimuons(hdr.fNDimuons),
 270   fEventType(hdr.fEventType),
 271   fOrbitNumber(hdr.fOrbitNumber),
 272   fPeriodNumber(hdr.fPeriodNumber),
 273   fBunchCrossNumber(hdr.fBunchCrossNumber),
 274   fRefMultComb05(hdr.fRefMultComb05),
 275   fRefMultComb08(hdr.fRefMultComb08),
 276   fTriggerCluster(hdr.fTriggerCluster),
 277   fDiamondZ(hdr.fDiamondZ),
 278   fDiamondSig2Z(hdr.fDiamondSig2Z),
 279   fOfflineTrigger(hdr.fOfflineTrigger),
 280   fESDFileName(hdr.fESDFileName),
 281   fEventNumberESDFile(hdr.fEventNumberESDFile),
 282   fL0TriggerInputs(hdr.fL0TriggerInputs),
 283   fL1TriggerInputs(hdr.fL1TriggerInputs),
 284   fL2TriggerInputs(hdr.fL2TriggerInputs),
 285   fTPConlyRefMult(hdr.fTPConlyRefMult),
 286   fCentralityP(new AliCentrality(*hdr.fCentralityP)),
 287   fEventplaneP(new AliEventplane(*hdr.fEventplaneP)),
 288   fIRInt2InteractionsMap(hdr.fIRInt2InteractionsMap),
 289   fIRInt1InteractionsMap(hdr.fIRInt1InteractionsMap)
 290 {
 291   // Copy constructor.
 292
 293   SetName(hdr.fName);
 294   SetTitle(hdr.fTitle);
 295   SetQTheta(hdr.fQTheta, hdr.fNQTheta);
 296   SetZDCEMEnergy(hdr.fZDCEMEnergy[0], hdr.fZDCEMEnergy[1]);
 297   for(Int_t i=0; i<2; i++) fDiamondXY[i]=hdr.fDiamondXY[i];
 298   for(Int_t i=0; i<3; i++) fDiamondCovXY[i]=hdr.fDiamondCovXY[i];
 299
 300
 301   for(Int_t m=0; m<kNPHOSMatrix; m++){
 302       if(hdr.fPHOSMatrix[m])
 303           fPHOSMatrix[m]=new TGeoHMatrix(*(hdr.fPHOSMatrix[m])) ;
 304       else
 305           fPHOSMatrix[m]=0;
 306   }
 307
 308   for(Int_t sm=0; sm<kNEMCALMatrix; sm++){
 309       if(hdr.fEMCALMatrix[sm])
 310           fEMCALMatrix[sm]=new TGeoHMatrix(*(hdr.fEMCALMatrix[sm])) ;
 311       else
 312           fEMCALMatrix[sm]=0;
 313   }
 314   for (Int_t i = 0; i < 6; i++)  fITSClusters[i] = hdr.fITSClusters[i];
 315   for (Int_t j=0; j<64; ++j) fVZEROEqFactors[j]=hdr.fVZEROEqFactors[j];
 316   for (Int_t i=0; i<kT0SpreadSize;i++) fT0spread[i]=hdr.fT0spread[i];
 317
 318 }
 319
 320 //______________________________________________________________________________
 321 AliAODHeader& AliAODHeader::operator=(const AliAODHeader& hdr)
 322 {
 323   // Assignment operator
 324   if(this!=&hdr) {
 325
 326      AliVHeader::operator=(hdr);
 327
 328     fMagneticField    = hdr.fMagneticField;
 329     fMuonMagFieldScale= hdr.fMuonMagFieldScale;
 330     fCentrality       = hdr.fCentrality;
 331     fEventplane       = hdr.fEventplane;
 332     fEventplaneMag    = hdr.fEventplaneMag;
 333     fEventplaneQx     = hdr.fEventplaneQx;
 334     fEventplaneQy     = hdr.fEventplaneQy;
 335     fZDCN1Energy      = hdr.fZDCN1Energy;
 336     fZDCP1Energy      = hdr.fZDCP1Energy;
 337     fZDCN2Energy      = hdr.fZDCN2Energy;
 338     fZDCP2Energy      = hdr.fZDCP2Energy;
 339     fTriggerMask      = hdr.fTriggerMask;
 340     fFiredTriggers    = hdr.fFiredTriggers;
 341     fRunNumber        = hdr.fRunNumber;
 342     fRefMult          = hdr.fRefMult;
 343     fRefMultPos       = hdr.fRefMultPos;
 344     fRefMultNeg       = hdr.fRefMultNeg;
 345     fEventType        = hdr.fEventType;
 346     fOrbitNumber      = hdr.fOrbitNumber;
 347     fPeriodNumber     = hdr.fPeriodNumber;
 348     fBunchCrossNumber = hdr.fBunchCrossNumber;
 349     fRefMultComb05    = hdr.fRefMultComb05;
 350     fRefMultComb08    = hdr.fRefMultComb08;
 351
 352     fTriggerCluster   = hdr.fTriggerCluster;
 353     fNMuons           = hdr.fNMuons;
 354     fNDimuons         = hdr.fNDimuons;
 355     fDiamondZ         = hdr.fDiamondZ;
 356     fDiamondSig2Z     = hdr.fDiamondSig2Z;
 357     fOfflineTrigger   = hdr.fOfflineTrigger;
 358     fESDFileName      = hdr.fESDFileName;
 359     fEventNumberESDFile = hdr.fEventNumberESDFile;
 360     fL0TriggerInputs    = hdr.fL0TriggerInputs;
 361     fL1TriggerInputs    = hdr.fL1TriggerInputs;
 362     fL2TriggerInputs    = hdr.fL2TriggerInputs;
 363     fTPConlyRefMult     = hdr.fTPConlyRefMult;
 364
 365     fIRInt2InteractionsMap  = hdr.fIRInt2InteractionsMap;
 366     fIRInt1InteractionsMap  = hdr.fIRInt1InteractionsMap;
 367
 368     if(hdr.fEventplaneP){
 369       if(fEventplaneP)*fEventplaneP = *hdr.fEventplaneP;
 370       else fEventplaneP = new AliEventplane(*hdr.fEventplaneP);
 371     }
 372
 373     if(hdr.fCentralityP){
 374       if(fCentralityP)*fCentralityP = *hdr.fCentralityP;
 375       else fCentralityP = new AliCentrality(*hdr.fCentralityP);
 376     }
 377
 378     SetName(hdr.fName);
 379     SetTitle(hdr.fTitle);
 380     SetQTheta(hdr.fQTheta, hdr.fNQTheta);
 381     SetZDCEMEnergy(hdr.fZDCEMEnergy[0], hdr.fZDCEMEnergy[1]);
 382     for(Int_t i=0; i<2; i++) fDiamondXY[i]=hdr.fDiamondXY[i];
 383     for(Int_t i=0; i<3; i++) fDiamondCovXY[i]=hdr.fDiamondCovXY[i];
 384
 385     for(Int_t m=0; m<kNPHOSMatrix; m++){
 386       if(hdr.fPHOSMatrix[m]){
 387         if(fPHOSMatrix[m])delete fPHOSMatrix[m];
 388         fPHOSMatrix[m]=new TGeoHMatrix(*(hdr.fPHOSMatrix[m])) ;
 389       }
 390       else
 391         fPHOSMatrix[m]=0;
 392     }
 393
 394     for(Int_t sm=0; sm<kNEMCALMatrix; sm++){
 395       if(hdr.fEMCALMatrix[sm]){
 396         if(fEMCALMatrix[sm])delete fEMCALMatrix[sm];
 397         fEMCALMatrix[sm]=new TGeoHMatrix(*(hdr.fEMCALMatrix[sm])) ;
 398       }
 399       else
 400         fEMCALMatrix[sm]=0;
 401     }
 402
 403   }
 404
 405   for (Int_t i = 0; i < 6; i++)  fITSClusters[i] = hdr.fITSClusters[i];
 406   for (Int_t j=0; j<64; ++j) fVZEROEqFactors[j] = hdr.fVZEROEqFactors[j];
 407   for (Int_t i=0; i<kT0SpreadSize;i++) fT0spread[i]=hdr.fT0spread[i];
 408
 409   return *this;
 410 }
 411
 412 //______________________________________________________________________________
 413 void AliAODHeader::SetQTheta(Double_t *QTheta, UInt_t size)
 414 {
 415   if (QTheta && size>0) {
 416     if (size != (UInt_t)fNQTheta) {
 417       RemoveQTheta();
 418       fNQTheta = size;
 419       fQTheta = new Double_t[fNQTheta];
 420     }
 421
 422     for (Int_t i = 0; i < fNQTheta; i++) {
 423       fQTheta[i] = QTheta[i];
 424     }
 425   } else {
 426     RemoveQTheta();
 427   }
 428
 429   return;
 430 }
 431
 432 //______________________________________________________________________________
 433 Double_t AliAODHeader::GetQTheta(UInt_t i) const
 434 {
 435   if (fQTheta && i < (UInt_t)fNQTheta) {
 436     return fQTheta[i];
 437   } else {
 438     return -999.;
 439   }
 440 }
 441
 442 //______________________________________________________________________________
 443 void AliAODHeader::RemoveQTheta()
 444 {
 445   delete[] fQTheta;
 446   fQTheta = 0x0;
 447   fNQTheta = 0;
 448
 449   return;
 450 }
 451
 452 void AliAODHeader::Clear(Option_t* /*opt*/)
 453 {
 454 // Clear memory
 455   RemoveQTheta();
 456   if (fCentralityP){
 457     delete fCentralityP;
 458     fCentralityP = 0;
 459     fCentrality = -999;
 460   }
 461   if (fEventplaneP){
 462     delete fEventplaneP;
 463     fEventplaneP = 0;
 464     fEventplane = -999;
 465     fEventplaneMag = -999.;
 466     fEventplaneQx = -999.;
 467     fEventplaneQy = -999.;
 468   }
 469   return;
 470 }
 471
 472 //______________________________________________________________________________
 473 void AliAODHeader::Print(Option_t* /*option*/) const
 474 {
 475   // prints event information
 476
 477   printf("Run #                   : %d\n", fRunNumber);
 478   printf("Bunch Crossing  #       : %d\n", fBunchCrossNumber);
 479   printf("Orbit Number #          : %d\n", fOrbitNumber);
 480   printf("Period Number #         : %d\n", fPeriodNumber);
 481   printf("Trigger mask            : %lld\n", fTriggerMask);
 482   printf("Trigger cluster         : %d\n", fTriggerCluster);
 483   printf("Event Type              : %d\n", fEventType);
 484   printf("Magnetic field          : %f\n", fMagneticField);
 485   printf("Muon mag. field scale   : %f\n", fMuonMagFieldScale);
 486
 487   printf("Centrality              : %f\n", fCentrality);
 488   printf("Event plane Ang         : %f\n", fEventplane);
 489   printf("Event plane Mag         : %f\n", fEventplaneMag);
 490   printf("Event plane Qx          : %f\n", fEventplaneQx);
 491   printf("Event plane Qy          : %f\n", fEventplaneQy);
 492   printf("ZDC N1 Energy           : %f\n", fZDCN1Energy);
 493   printf("ZDC P1 Energy           : %f\n", fZDCP1Energy);
 494   printf("ZDC N2 Energy           : %f\n", fZDCN2Energy);
 495   printf("ZDC P2 Energy           : %f\n", fZDCP2Energy);
 496   printf("ZDC EM1 Energy          : %f\n", fZDCEMEnergy[0]);
 497   printf("ZDC EM2 Energy          : %f\n", fZDCEMEnergy[1]);
 498   printf("ref. Multiplicity       : %d\n", fRefMult);
 499   printf("ref. Multiplicity (pos) : %d\n", fRefMultPos);
 500   printf("ref. Multiplicity (neg) : %d\n", fRefMultNeg);
 501   printf("ref. Mult.Comb |eta|<.5 : %d\n", fRefMultComb05);
 502   printf("ref. Mult.Comb |eta|<.8 : %d\n", fRefMultComb08);
 503   printf("number of muons         : %d\n", fNMuons);
 504   printf("number of dimuons       : %d\n", fNDimuons);
 505   printf("offline trigger         : %u\n", fOfflineTrigger);
 506
 507   if (fQTheta) {
 508     for (UInt_t i = 0; i<(UInt_t)fNQTheta; i++) {
 509       printf("QTheta[%d]              : %13.3e\n", i, GetQTheta(i));
 510     }
 511   }
 512   printf("V0 Eq factors: ");
 513   for (Int_t j=0; j<64; ++j) printf(" %.3f",fVZEROEqFactors[j]);
 514   printf("\n");
 515
 516   return;
 517 }
 518
 519 //__________________________________________________________________________
 520 Int_t AliAODHeader::FindIRIntInteractionsBXMap(Int_t difference)
 521 {
 522   //
 523   // The mapping is of 181 bits, from -90 to +90
 524   //
 525   Int_t bin=-1;
 526
 527   if(difference<-90 || difference>90) return bin;
 528   else { bin = 90 + difference; }
 529
 530   return bin;
 531 }
 532
 533 //__________________________________________________________________________
 534 Int_t AliAODHeader::GetIRInt2ClosestInteractionMap()
 535 {
 536   //
 537   // Calculation of the closest interaction
 538   //
 539   Int_t firstNegative=100;
 540   for(Int_t item=-1; item>=-90; item--) {
 541     Int_t bin = FindIRIntInteractionsBXMap(item);
 542     Bool_t isFired = fIRInt2InteractionsMap.TestBitNumber(bin);
 543     if(isFired) {
 544       firstNegative = item;
 545       break;
 546     }
 547   }
 548   Int_t firstPositive=100;
 549   for(Int_t item=1; item<=90; item++) {
 550     Int_t bin = FindIRIntInteractionsBXMap(item);
 551     Bool_t isFired = fIRInt2InteractionsMap.TestBitNumber(bin);
 552     if(isFired) {
 553       firstPositive = item;
 554       break;
 555     }
 556   }
 557
 558   Int_t closest = firstPositive < TMath::Abs(firstNegative) ? firstPositive : TMath::Abs(firstNegative);
 559   if(firstPositive==100 && firstNegative==100) closest=0;
 560   return closest;
 561 }
 562
 563 //__________________________________________________________________________
 564 Int_t AliAODHeader::GetIRInt1ClosestInteractionMap(Int_t gap)
 565 {
 566   //
 567   // Calculation of the closest interaction
 568   // In case of VZERO (Int1) one has to introduce a gap
 569   // in order to avoid false positivies from after-pulses
 570
 571   Int_t firstNegative=100;
 572   for(Int_t item=-1; item>=-90; item--) {
 573     Int_t bin = FindIRIntInteractionsBXMap(item);
 574     Bool_t isFired = fIRInt1InteractionsMap.TestBitNumber(bin);
 575     if(isFired) {
 576       firstNegative = item;
 577       break;
 578     }
 579   }
 580   Int_t firstPositive=100;
 581   for(Int_t item=1+gap; item<=90; item++) {
 582     Int_t bin = FindIRIntInteractionsBXMap(item);
 583     Bool_t isFired = fIRInt1InteractionsMap.TestBitNumber(bin);
 584     if(isFired) {
 585       firstPositive = item;
 586       break;
 587     }
 588   }
 589
 590   Int_t closest = firstPositive < TMath::Abs(firstNegative) ? firstPositive : TMath::Abs(firstNegative);
 591   if(firstPositive==100 && firstNegative==100) closest=0;
 592   return closest;
 593 }
 594
 595 //__________________________________________________________________________
 596 Int_t AliAODHeader::GetIRInt2LastInteractionMap()
 597 {
 598   //
 599   // Calculation of the last interaction
 600   //
 601   Int_t lastNegative=0;
 602   for(Int_t item=-90; item<=-1; item++) {
 603     Int_t bin = FindIRIntInteractionsBXMap(item);
 604     Bool_t isFired = fIRInt2InteractionsMap.TestBitNumber(bin);
 605     if(isFired) {
 606       lastNegative = item;
 607       break;
 608     }
 609   }
 610   Int_t lastPositive=0;
 611   for(Int_t item=90; item>=1; item--) {
 612     Int_t bin = FindIRIntInteractionsBXMap(item);
 613     Bool_t isFired = fIRInt2InteractionsMap.TestBitNumber(bin);
 614     if(isFired) {
 615       lastPositive = item;
 616       break;
 617     }
 618   }
 619
 620   Int_t last = lastPositive > TMath::Abs(lastNegative) ? lastPositive : TMath::Abs(lastNegative);
 621   return last;
 622 }