STEER/AliESDRun.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 #include <TNamed.h>
  16 #include <TGeoMatrix.h>
  17 #include <TGeoGlobalMagField.h>
  18
  19 #include "AliESDRun.h"
  20 #include "AliESDVertex.h"
  21 #include "AliLog.h"
  22 #include "AliMagF.h"
  23
  24 //-------------------------------------------------------------------------
  25 //                     Implementation Class AliESDRun
  26 //   Run by run data
  27 //   for the ESD
  28 //   Origin: Christian Klein-Boesing, CERN, Christian.Klein-Boesing@cern.ch
  29 //-------------------------------------------------------------------------
  30
  31 ClassImp(AliESDRun)
  32
  33 //______________________________________________________________________________
  34 AliESDRun::AliESDRun() :
  35   TObject(),
  36   fCurrentL3(0),
  37   fCurrentDip(0),
  38   fBeamEnergy(0),
  39   fMagneticField(0),
  40   fDiamondZ(0),
  41   fDiamondSig2Z(0),
  42   fPeriodNumber(0),
  43   fRunNumber(0),
  44   fRecoVersion(0),
  45   fBeamType(""),
  46   fTriggerClasses(kNTriggerClasses),
  47   fDetInDAQ(0),
  48   fDetInReco(0)
  49
  50 {
  51   for (Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
  52   fDiamondCovXY[0]=fDiamondCovXY[2]=3.*3.;
  53   fDiamondCovXY[1]=0.;
  54   fTriggerClasses.SetOwner(kTRUE);
  55   fMeanBeamInt[0][0]=fMeanBeamInt[0][1]=fMeanBeamInt[1][0]=fMeanBeamInt[1][1]=-1;
  56   for (Int_t m=0; m<kNPHOSMatrix; m++) fPHOSMatrix[m]=NULL;
  57   for (Int_t sm=0; sm<kNEMCALMatrix; sm++) fEMCALMatrix[sm]=NULL;
  58   for (Int_t i=0; i<kT0spreadSize;i++) fT0spread[i]=0.;
  59 }
  60
  61 //______________________________________________________________________________
  62 AliESDRun::AliESDRun(const AliESDRun &esd) :
  63   TObject(esd),
  64   fCurrentL3(0),
  65   fCurrentDip(0),
  66   fBeamEnergy(0),
  67   fMagneticField(esd.fMagneticField),
  68   fDiamondZ(esd.fDiamondZ),
  69   fDiamondSig2Z(esd.fDiamondSig2Z),
  70   fPeriodNumber(esd.fPeriodNumber),
  71   fRunNumber(esd.fRunNumber),
  72   fRecoVersion(esd.fRecoVersion),
  73   fBeamType(""),
  74   fTriggerClasses(TObjArray(kNTriggerClasses)),
  75   fDetInDAQ(0),
  76   fDetInReco(0)
  77 {
  78   // Copy constructor
  79   for (Int_t i=0; i<2; i++) fDiamondXY[i]=esd.fDiamondXY[i];
  80   for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=esd.fDiamondCovXY[i];
  81
  82   for(Int_t i = 0; i < kNTriggerClasses; i++) {
  83     TNamed *str = (TNamed *)((esd.fTriggerClasses).At(i));
  84     if (str) fTriggerClasses.AddAt(new TNamed(*str),i);
  85   }
  86
  87   for(Int_t m=0; m<kNPHOSMatrix; m++){
  88     if(esd.fPHOSMatrix[m])
  89       fPHOSMatrix[m]=new TGeoHMatrix(*(esd.fPHOSMatrix[m])) ;
  90     else
  91       fPHOSMatrix[m]=NULL;
  92   }
  93
  94   for (int ib=2;ib--;) for (int it=2;it--;) fMeanBeamInt[ib][it] = esd.fMeanBeamInt[ib][it];
  95
  96   for(Int_t sm=0; sm<kNEMCALMatrix; sm++){
  97         if(esd.fEMCALMatrix[sm])
  98                 fEMCALMatrix[sm]=new TGeoHMatrix(*(esd.fEMCALMatrix[sm])) ;
  99         else
 100                 fEMCALMatrix[sm]=NULL;
 101   }
 102   for (Int_t i=0; i<kT0spreadSize;i++) fT0spread[i]=esd.fT0spread[i];
 103
 104 }
 105
 106 //______________________________________________________________________________
 107 AliESDRun& AliESDRun::operator=(const AliESDRun &esd)
 108 {
 109   // assigment operator
 110   if(this!=&esd) {
 111     TObject::operator=(esd);
 112     fRunNumber=esd.fRunNumber;
 113     fPeriodNumber=esd.fPeriodNumber;
 114     fRecoVersion=esd.fRecoVersion;
 115     fMagneticField=esd.fMagneticField;
 116     fDiamondZ=esd.fDiamondZ;
 117     fDiamondSig2Z=esd.fDiamondSig2Z;
 118     fBeamType = esd.fBeamType;
 119     fCurrentL3  = esd.fCurrentL3;
 120     fCurrentDip = esd.fCurrentDip;
 121     fBeamEnergy = esd.fBeamEnergy;
 122     for (Int_t i=0; i<2; i++) fDiamondXY[i]=esd.fDiamondXY[i];
 123     for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=esd.fDiamondCovXY[i];
 124     fTriggerClasses.Clear();
 125     for(Int_t i = 0; i < kNTriggerClasses; i++) {
 126       TNamed *str = (TNamed *)((esd.fTriggerClasses).At(i));
 127       if (str) fTriggerClasses.AddAt(new TNamed(*str),i);
 128     }
 129
 130     fDetInDAQ   = esd.fDetInDAQ;
 131     fDetInReco  = esd.fDetInReco;
 132
 133     for (int ib=2;ib--;) for (int it=2;it--;) fMeanBeamInt[ib][it] = esd.fMeanBeamInt[ib][it];
 134
 135     for(Int_t m=0; m<kNPHOSMatrix; m++){
 136       if(esd.fPHOSMatrix[m])
 137         fPHOSMatrix[m]=new TGeoHMatrix(*(esd.fPHOSMatrix[m])) ;
 138       else
 139         fPHOSMatrix[m]=0;
 140     }
 141
 142         for(Int_t sm=0; sm<kNEMCALMatrix; sm++){
 143           if(esd.fEMCALMatrix[sm])
 144                   fEMCALMatrix[sm]=new TGeoHMatrix(*(esd.fEMCALMatrix[sm])) ;
 145           else
 146                   fEMCALMatrix[sm]=0;
 147         }
 148   }
 149   for (Int_t i=0; i<kT0spreadSize;i++) fT0spread[i]=esd.fT0spread[i];
 150   return *this;
 151 }
 152
 153 void AliESDRun::Copy(TObject &obj) const{
 154
 155   // this overwrites the virtual TOBject::Copy()
 156   // to allow run time copying without casting
 157   // in AliESDEvent
 158
 159   if(this==&obj)return;
 160   AliESDRun *robj = dynamic_cast<AliESDRun*>(&obj);
 161   if(!robj)return; // not an aliesdrun
 162   *robj = *this;
 163
 164 }
 165
 166 //______________________________________________________________________________
 167 AliESDRun::~AliESDRun() {
 168   // Destructor
 169   // Delete PHOS position matrices
 170   for(Int_t m=0; m<kNPHOSMatrix; m++) {
 171     if(fPHOSMatrix[m]) delete fPHOSMatrix[m] ;
 172     fPHOSMatrix[m] = NULL;
 173   }
 174   // Delete PHOS position matrices
 175   for(Int_t sm=0; sm<kNEMCALMatrix; sm++) {
 176         if(fEMCALMatrix[sm]) delete fEMCALMatrix[sm] ;
 177         fEMCALMatrix[sm] = NULL;
 178   }
 179 }
 180
 181 void AliESDRun::SetDiamond(const AliESDVertex *vertex) {
 182   // set the interaction diamond
 183   if (vertex) {
 184     fDiamondXY[0]=vertex->GetXv();
 185     fDiamondXY[1]=vertex->GetYv();
 186     fDiamondZ=vertex->GetZv();
 187     Double32_t cov[6];
 188     vertex->GetCovMatrix(cov);
 189     fDiamondCovXY[0]=cov[0];
 190     fDiamondCovXY[1]=cov[1];
 191     fDiamondCovXY[2]=cov[2];
 192     fDiamondSig2Z=cov[5];
 193   }
 194 }
 195
 196
 197 //______________________________________________________________________________
 198 void AliESDRun::Print(const Option_t *) const
 199 {
 200   // Print some data members
 201   printf("Mean vertex in RUN %d: X=%.4f Y=%.4f Z=%.4f cm\n",
 202          GetRunNumber(),GetDiamondX(),GetDiamondY(),GetDiamondZ());
 203   printf("Beam Type: %s, Energy: %.1f GeV\n",fBeamType.IsNull() ? "N/A":fBeamType.Data(),fBeamEnergy);
 204   printf("Magnetic field in IP= %f T | Currents: L3:%+.1f Dipole:%+.1f %s\n",
 205          GetMagneticField(),fCurrentL3,fCurrentDip,TestBit(kUniformBMap) ? "(Uniform)":"");
 206   printf("Event from reconstruction version %d \n",fRecoVersion);
 207
 208   printf("List of active trigger classes: ");
 209   for(Int_t i = 0; i < kNTriggerClasses; i++) {
 210     TNamed *str = (TNamed *)((fTriggerClasses).At(i));
 211     if (str) printf("%s ",str->GetName());
 212   }
 213   printf("Mean intenstity for interacting   : beam1:%+.3e beam2:%+.3e\n",fMeanBeamInt[0][0],fMeanBeamInt[1][0]);
 214   printf("Mean intenstity for non-intecting : beam1:%+.3e beam2:%+.3e\n",fMeanBeamInt[0][1],fMeanBeamInt[1][1]);
 215   printf("\n");
 216 }
 217
 218 void AliESDRun::Reset()
 219 {
 220   // reset data members
 221   fRunNumber = 0;
 222   fPeriodNumber = 0;
 223   fRecoVersion = 0;
 224   fMagneticField = 0;
 225   fCurrentL3 = 0;
 226   fCurrentDip = 0;
 227   fBeamEnergy = 0;
 228   fBeamType = "";
 229   ResetBit(kBInfoStored|kUniformBMap|kConvSqrtSHalfGeV);
 230   for (Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
 231   fDiamondCovXY[0]=fDiamondCovXY[2]=3.*3.;
 232   fDiamondCovXY[1]=0.;
 233   fDiamondZ=0.;
 234   fDiamondSig2Z=10.*10.;
 235   fTriggerClasses.Clear();
 236   fDetInDAQ   = 0;
 237   fDetInReco  = 0;
 238 }
 239
 240 //______________________________________________________________________________
 241 void AliESDRun::SetTriggerClass(const char*name, Int_t index)
 242 {
 243   // Fill the trigger class name
 244   // into the corresponding array
 245   if (index >= kNTriggerClasses || index < 0) {
 246     AliError(Form("Index (%d) is outside the allowed range (0,49)!",index));
 247     return;
 248   }
 249
 250   fTriggerClasses.AddAt(new TNamed(name,NULL),index);
 251 }
 252
 253 //______________________________________________________________________________
 254 const char* AliESDRun::GetTriggerClass(Int_t index) const
 255 {
 256   // Get the trigger class name at
 257   // specified position in the trigger mask
 258   TNamed *trclass = (TNamed *)fTriggerClasses.At(index);
 259   if (trclass)
 260     return trclass->GetName();
 261   else
 262     return "";
 263 }
 264
 265 //______________________________________________________________________________
 266 TString AliESDRun::GetActiveTriggerClasses() const
 267 {
 268   // Construct and return
 269   // the list of trigger classes
 270   // which are present in the run
 271   TString trclasses;
 272   for(Int_t i = 0; i < kNTriggerClasses; i++) {
 273     TNamed *str = (TNamed *)((fTriggerClasses).At(i));
 274     if (str) {
 275       trclasses += " ";
 276       trclasses += str->GetName();
 277       trclasses += " ";
 278     }
 279   }
 280
 281   return trclasses;
 282 }
 283
 284 //______________________________________________________________________________
 285 TString AliESDRun::GetFiredTriggerClasses(ULong64_t mask) const
 286 {
 287   // Constructs and returns the
 288   // list of trigger classes that
 289   // have been fired. Uses the trigger
 290   // class mask as an argument.
 291   TString trclasses;
 292   for(Int_t i = 0; i < kNTriggerClasses; i++) {
 293     if (mask & (1ull << i)) {
 294       TNamed *str = (TNamed *)((fTriggerClasses).At(i));
 295       if (str) {
 296         trclasses += " ";
 297         trclasses += str->GetName();
 298       trclasses += " ";
 299       }
 300     }
 301   }
 302
 303   return trclasses;
 304 }
 305
 306 //______________________________________________________________________________
 307 Bool_t AliESDRun::IsTriggerClassFired(ULong64_t mask, const char *name) const
 308 {
 309   // Checks if the trigger class
 310   // identified by 'name' has been
 311   // fired. Uses the trigger class mask.
 312
 313   TNamed *trclass = (TNamed *)fTriggerClasses.FindObject(name);
 314   if (!trclass) return kFALSE;
 315
 316   Int_t iclass = fTriggerClasses.IndexOf(trclass);
 317   if (iclass < 0) return kFALSE;
 318
 319   if (mask & (1ull << iclass))
 320     return kTRUE;
 321   else
 322     return kFALSE;
 323 }
 324
 325 //_____________________________________________________________________________
 326 Bool_t AliESDRun::InitMagneticField() const
 327 {
 328   // Create mag field from stored information
 329   //
 330   if (!TestBit(kBInfoStored)) {
 331     AliError("No information on currents, cannot create field from run header");
 332     return kFALSE;
 333   }
 334   //
 335   if ( TGeoGlobalMagField::Instance()->IsLocked() ) {
 336     if (TGeoGlobalMagField::Instance()->GetField()->TestBit(AliMagF::kOverrideGRP)) {
 337       AliInfo("ExpertMode!!! Information on magnet currents will be ignored !");
 338       AliInfo("ExpertMode!!! Running with the externally locked B field !");
 339       return kTRUE;
 340     }
 341     else {
 342       AliInfo("Destroying existing B field instance!");
 343       delete TGeoGlobalMagField::Instance();
 344     }
 345   }
 346   //
 347   AliMagF* fld = AliMagF::CreateFieldMap(fCurrentL3,fCurrentDip,AliMagF::kConvLHC,
 348                                          TestBit(kUniformBMap), GetBeamEnergy(), GetBeamType());
 349   if (fld) {
 350     TGeoGlobalMagField::Instance()->SetField( fld );
 351     TGeoGlobalMagField::Instance()->Lock();
 352     AliInfo("Running with the B field constructed out of the Run Header !");
 353     return kTRUE;
 354   }
 355   else {
 356     AliError("Failed to create a B field map !");
 357     return kFALSE;
 358   }
 359   //
 360 }
 361
 362 //_____________________________________________________________________________
 363 void AliESDRun::SetT0spread(Int_t i,Float_t t)
 364 {
 365   //
 366   // Setting the T0 spread value at index i
 367   //
 368
 369   if ( (i>=0) && (i<kT0spreadSize)) {
 370     fT0spread[i]=t;
 371   } else {
 372     AliError(Form("Index %d out of bound",i));
 373   }
 374   return;
 375 }
 376
 377 //_____________________________________________________________________________
 378 void AliESDRun::SetT0spread(Float_t *t)
 379 {
 380   //
 381   // Setting the T0 spread values
 382   //
 383   if (t == 0x0){
 384     AliError(Form("Null pointer passed"));
 385   }
 386   else{
 387     for (Int_t i=0;i<kT0spreadSize;i++) fT0spread[i]=t[i];
 388   }
 389   return;
 390 }
 391