[u/mrichter/AliRoot.git] / STEER / AliESDRun.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/
#include <TNamed.h>
#include <TGeoMatrix.h>
#include <TGeoGlobalMagField.h>

#include "AliESDRun.h"
#include "AliESDVertex.h"
#include "AliLog.h"
#include "AliMagF.h"

//-------------------------------------------------------------------------
//                     Implementation Class AliESDRun
//   Run by run data
//   for the ESD   
//   Origin: Christian Klein-Boesing, CERN, Christian.Klein-Boesing@cern.ch 
//-------------------------------------------------------------------------

ClassImp(AliESDRun)  
 
//______________________________________________________________________________
AliESDRun::AliESDRun() :
  TObject(),
  fCurrentL3(0),
  fCurrentDip(0),
  fBeamEnergy(0),
  fMagneticField(0),
  fDiamondZ(0),
  fDiamondSig2Z(0),
  fPeriodNumber(0),
  fRunNumber(0),
  fRecoVersion(0),
  fBeamType(""),
  fTriggerClasses(kNTriggerClasses),
  fDetInDAQ(0),
  fDetInReco(0)
  
{
  for (Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
  fDiamondCovXY[0]=fDiamondCovXY[2]=3.*3.;
  fDiamondCovXY[1]=0.;
  fTriggerClasses.SetOwner(kTRUE);
  fMeanBeamInt[0][0]=fMeanBeamInt[0][1]=fMeanBeamInt[1][0]=fMeanBeamInt[1][1]=-1;
  for (Int_t m=0; m<kNPHOSMatrix; m++) fPHOSMatrix[m]=NULL;
  for (Int_t sm=0; sm<kNEMCALMatrix; sm++) fEMCALMatrix[sm]=NULL;
  for (Int_t i=0; i<kT0spreadSize;i++) fT0spread[i]=0.;
}

//______________________________________________________________________________
AliESDRun::AliESDRun(const AliESDRun &esd) :
  TObject(esd),
  fCurrentL3(0),
  fCurrentDip(0),
  fBeamEnergy(0),
  fMagneticField(esd.fMagneticField),
  fDiamondZ(esd.fDiamondZ),
  fDiamondSig2Z(esd.fDiamondSig2Z),
  fPeriodNumber(esd.fPeriodNumber),
  fRunNumber(esd.fRunNumber),
  fRecoVersion(esd.fRecoVersion),
  fBeamType(""),
  fTriggerClasses(TObjArray(kNTriggerClasses)),
  fDetInDAQ(0),
  fDetInReco(0)
{ 
  // Copy constructor
  for (Int_t i=0; i<2; i++) fDiamondXY[i]=esd.fDiamondXY[i];
  for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=esd.fDiamondCovXY[i];

  for(Int_t i = 0; i < kNTriggerClasses; i++) {
    TNamed *str = (TNamed *)((esd.fTriggerClasses).At(i));
    if (str) fTriggerClasses.AddAt(new TNamed(*str),i);
  }

  for(Int_t m=0; m<kNPHOSMatrix; m++){
    if(esd.fPHOSMatrix[m])
      fPHOSMatrix[m]=new TGeoHMatrix(*(esd.fPHOSMatrix[m])) ;
    else
      fPHOSMatrix[m]=NULL;
  }
  
  for (int ib=2;ib--;) for (int it=2;it--;) fMeanBeamInt[ib][it] = esd.fMeanBeamInt[ib][it];

  for(Int_t sm=0; sm<kNEMCALMatrix; sm++){
	if(esd.fEMCALMatrix[sm])
		fEMCALMatrix[sm]=new TGeoHMatrix(*(esd.fEMCALMatrix[sm])) ;
	else
		fEMCALMatrix[sm]=NULL;
  }
  for (Int_t i=0; i<kT0spreadSize;i++) fT0spread[i]=esd.fT0spread[i];

}

//______________________________________________________________________________
AliESDRun& AliESDRun::operator=(const AliESDRun &esd)
{ 
  // assigment operator
  if(this!=&esd) {
    TObject::operator=(esd);
    fRunNumber=esd.fRunNumber;
    fPeriodNumber=esd.fPeriodNumber;
    fRecoVersion=esd.fRecoVersion;
    fMagneticField=esd.fMagneticField;
    fDiamondZ=esd.fDiamondZ;
    fDiamondSig2Z=esd.fDiamondSig2Z;
    fBeamType = esd.fBeamType;
    fCurrentL3  = esd.fCurrentL3;
    fCurrentDip = esd.fCurrentDip;
    fBeamEnergy = esd.fBeamEnergy;
    for (Int_t i=0; i<2; i++) fDiamondXY[i]=esd.fDiamondXY[i];
    for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=esd.fDiamondCovXY[i];
    fTriggerClasses.Clear();
    for(Int_t i = 0; i < kNTriggerClasses; i++) {
      TNamed *str = (TNamed *)((esd.fTriggerClasses).At(i));
      if (str) fTriggerClasses.AddAt(new TNamed(*str),i);
    }

    fDetInDAQ   = esd.fDetInDAQ;
    fDetInReco  = esd.fDetInReco;

    for (int ib=2;ib--;) for (int it=2;it--;) fMeanBeamInt[ib][it] = esd.fMeanBeamInt[ib][it];

    for(Int_t m=0; m<kNPHOSMatrix; m++){
      if(esd.fPHOSMatrix[m])
	fPHOSMatrix[m]=new TGeoHMatrix(*(esd.fPHOSMatrix[m])) ;
      else
	fPHOSMatrix[m]=0;
    }
	  
	for(Int_t sm=0; sm<kNEMCALMatrix; sm++){
	  if(esd.fEMCALMatrix[sm])
		  fEMCALMatrix[sm]=new TGeoHMatrix(*(esd.fEMCALMatrix[sm])) ;
	  else
		  fEMCALMatrix[sm]=0;
	}
  } 
  for (Int_t i=0; i<kT0spreadSize;i++) fT0spread[i]=esd.fT0spread[i];
  return *this;
}

void AliESDRun::Copy(TObject &obj) const{

  // this overwrites the virtual TOBject::Copy()
  // to allow run time copying without casting
  // in AliESDEvent

  if(this==&obj)return;
  AliESDRun *robj = dynamic_cast<AliESDRun*>(&obj);
  if(!robj)return; // not an aliesdrun
  *robj = *this;

}

//______________________________________________________________________________
AliESDRun::~AliESDRun() {
  // Destructor
  // Delete PHOS position matrices
  for(Int_t m=0; m<kNPHOSMatrix; m++) {
    if(fPHOSMatrix[m]) delete fPHOSMatrix[m] ;
    fPHOSMatrix[m] = NULL;
  }
  // Delete PHOS position matrices
  for(Int_t sm=0; sm<kNEMCALMatrix; sm++) {
	if(fEMCALMatrix[sm]) delete fEMCALMatrix[sm] ;
	fEMCALMatrix[sm] = NULL;
  }
}

void AliESDRun::SetDiamond(const AliESDVertex *vertex) {
  // set the interaction diamond
  fDiamondXY[0]=vertex->GetXv();
  fDiamondXY[1]=vertex->GetYv();
  fDiamondZ=vertex->GetZv();
  Double32_t cov[6];
  vertex->GetCovMatrix(cov);
  fDiamondCovXY[0]=cov[0];
  fDiamondCovXY[1]=cov[1];
  fDiamondCovXY[2]=cov[2];
  fDiamondSig2Z=cov[5];
}


//______________________________________________________________________________
void AliESDRun::Print(const Option_t *) const
{
  // Print some data members
  printf("Mean vertex in RUN %d: X=%.4f Y=%.4f Z=%.4f cm\n",
	 GetRunNumber(),GetDiamondX(),GetDiamondY(),GetDiamondZ());
  printf("Beam Type: %s, Energy: %.1f GeV\n",fBeamType.IsNull() ? "N/A":fBeamType.Data(),fBeamEnergy);
  printf("Magnetic field in IP= %f T | Currents: L3:%+.1f Dipole:%+.1f %s\n",
	 GetMagneticField(),fCurrentL3,fCurrentDip,TestBit(kUniformBMap) ? "(Uniform)":"");
  printf("Event from reconstruction version %d \n",fRecoVersion);
  
  printf("List of active trigger classes: ");
  for(Int_t i = 0; i < kNTriggerClasses; i++) {
    TNamed *str = (TNamed *)((fTriggerClasses).At(i));
    if (str) printf("%s ",str->GetName());
  }
  printf("Mean intenstity for interacting   : beam1:%+.3e beam2:%+.3e\n",fMeanBeamInt[0][0],fMeanBeamInt[1][0]);
  printf("Mean intenstity for non-intecting : beam1:%+.3e beam2:%+.3e\n",fMeanBeamInt[0][1],fMeanBeamInt[1][1]);
  printf("\n");
}

void AliESDRun::Reset() 
{
  // reset data members
  fRunNumber = 0;
  fPeriodNumber = 0;
  fRecoVersion = 0;
  fMagneticField = 0;
  fCurrentL3 = 0;
  fCurrentDip = 0;
  fBeamEnergy = 0;
  fBeamType = "";
  ResetBit(kBInfoStored|kUniformBMap|kConvSqrtSHalfGeV);
  for (Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
  fDiamondCovXY[0]=fDiamondCovXY[2]=3.*3.;
  fDiamondCovXY[1]=0.;
  fDiamondZ=0.;
  fDiamondSig2Z=10.*10.;
  fTriggerClasses.Clear();
  fDetInDAQ   = 0;
  fDetInReco  = 0;
}

//______________________________________________________________________________
void AliESDRun::SetTriggerClass(const char*name, Int_t index)
{
  // Fill the trigger class name
  // into the corresponding array
  if (index >= kNTriggerClasses || index < 0) {
    AliError(Form("Index (%d) is outside the allowed range (0,49)!",index));
    return;
  }

  fTriggerClasses.AddAt(new TNamed(name,NULL),index);
}

//______________________________________________________________________________
const char* AliESDRun::GetTriggerClass(Int_t index) const
{
  // Get the trigger class name at
  // specified position in the trigger mask
  TNamed *trclass = (TNamed *)fTriggerClasses.At(index);
  if (trclass)
    return trclass->GetName();
  else
    return "";
}

//______________________________________________________________________________
TString AliESDRun::GetActiveTriggerClasses() const
{
  // Construct and return
  // the list of trigger classes
  // which are present in the run
  TString trclasses;
  for(Int_t i = 0; i < kNTriggerClasses; i++) {
    TNamed *str = (TNamed *)((fTriggerClasses).At(i));
    if (str) {
      trclasses += " ";
      trclasses += str->GetName();
      trclasses += " ";
    }
  }

  return trclasses;
}

//______________________________________________________________________________
TString AliESDRun::GetFiredTriggerClasses(ULong64_t mask) const
{
  // Constructs and returns the
  // list of trigger classes that
  // have been fired. Uses the trigger
  // class mask as an argument.
  TString trclasses;
  for(Int_t i = 0; i < kNTriggerClasses; i++) {
    if (mask & (1ull << i)) {
      TNamed *str = (TNamed *)((fTriggerClasses).At(i));
      if (str) {
	trclasses += " ";
	trclasses += str->GetName();
      trclasses += " ";
      }
    }
  }

  return trclasses;
}

//______________________________________________________________________________
Bool_t AliESDRun::IsTriggerClassFired(ULong64_t mask, const char *name) const
{
  // Checks if the trigger class
  // identified by 'name' has been
  // fired. Uses the trigger class mask.

  TNamed *trclass = (TNamed *)fTriggerClasses.FindObject(name);
  if (!trclass) return kFALSE;

  Int_t iclass = fTriggerClasses.IndexOf(trclass);
  if (iclass < 0) return kFALSE;

  if (mask & (1ull << iclass))
    return kTRUE;
  else
    return kFALSE;
}

//_____________________________________________________________________________
Bool_t AliESDRun::InitMagneticField() const
{
  // Create mag field from stored information
  //
  if (!TestBit(kBInfoStored)) {
    AliError("No information on currents, cannot create field from run header");
    return kFALSE;
  }
  //
  if ( TGeoGlobalMagField::Instance()->IsLocked() ) {
    if (TGeoGlobalMagField::Instance()->GetField()->TestBit(AliMagF::kOverrideGRP)) {
      AliInfo("ExpertMode!!! Information on magnet currents will be ignored !");
      AliInfo("ExpertMode!!! Running with the externally locked B field !");
      return kTRUE;
    }
    else {
      AliInfo("Destroying existing B field instance!");
      delete TGeoGlobalMagField::Instance();
    }
  }
  //
  AliMagF* fld = AliMagF::CreateFieldMap(fCurrentL3,fCurrentDip,AliMagF::kConvLHC,
					 TestBit(kUniformBMap), GetBeamEnergy(), GetBeamType());
  if (fld) {
    TGeoGlobalMagField::Instance()->SetField( fld );
    TGeoGlobalMagField::Instance()->Lock();
    AliInfo("Running with the B field constructed out of the Run Header !");
    return kTRUE;
  }
  else {
    AliError("Failed to create a B field map !");
    return kFALSE;
  }
  //
}

//_____________________________________________________________________________
void AliESDRun::SetT0spread(Int_t i,Float_t t) 
{
  //
  // Setting the T0 spread value at index i 
  //

  if ( (i>=0) && (i<kT0spreadSize)) {
    fT0spread[i]=t;
  } else {
    AliError(Form("Index %d out of bound",i));
  }
  return;
}

//_____________________________________________________________________________
void AliESDRun::SetT0spread(Float_t *t) 
{
  //
  // Setting the T0 spread values
  //
  if (t == 0x0){
    AliError(Form("Null pointer passed"));
  }
  else{
    for (Int_t i=0;i<kT0spreadSize;i++) fT0spread[i]=t[i];
  }
  return;
}
Commit	Line	Data
d5ebf00e	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	**************************************************************************/
f009b5c1	15	#include <TNamed.h>
8d218603	16	#include <TGeoMatrix.h>
33fe5eb1	17	#include <TGeoGlobalMagField.h>
d5ebf00e	18
	19	#include "AliESDRun.h"
	20	#include "AliESDVertex.h"
f009b5c1	21	#include "AliLog.h"
33fe5eb1	22	#include "AliMagF.h"
d5ebf00e	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() :
694aad0c	35	TObject(),
33fe5eb1	36	fCurrentL3(0),
	37	fCurrentDip(0),
	38	fBeamEnergy(0),
694aad0c	39	fMagneticField(0),
1c7554f9	40	fDiamondZ(0),
1c7554f9	41	fDiamondSig2Z(0),
d5ebf00e	42	fPeriodNumber(0),
694aad0c	43	fRunNumber(0),
f009b5c1	44	fRecoVersion(0),
33fe5eb1	45	fBeamType(""),
7b649c02	46	fTriggerClasses(kNTriggerClasses),
	47	fDetInDAQ(0),
	48	fDetInReco(0)
d443e5e9	49
d5ebf00e	50	{
d5ebf00e	51	for (Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
a2dedd16	52	fDiamondCovXY[0]=fDiamondCovXY[2]=3.*3.;
a2dedd16	53	fDiamondCovXY[1]=0.;
f009b5c1	54	fTriggerClasses.SetOwner(kTRUE);
b671618d	55	fMeanBeamInt[0][0]=fMeanBeamInt[0][1]=fMeanBeamInt[1][0]=fMeanBeamInt[1][1]=-1;
8d218603	56	for (Int_t m=0; m<kNPHOSMatrix; m++) fPHOSMatrix[m]=NULL;
428557af	57	for (Int_t sm=0; sm<kNEMCALMatrix; sm++) fEMCALMatrix[sm]=NULL;
d443e5e9	58	for (Int_t i=0; i<kT0spreadSize;i++) fT0spread[i]=0.;
d5ebf00e	59	}
	60
	61	//______________________________________________________________________________
	62	AliESDRun::AliESDRun(const AliESDRun &esd) :
	63	TObject(esd),
33fe5eb1	64	fCurrentL3(0),
	65	fCurrentDip(0),
	66	fBeamEnergy(0),
694aad0c	67	fMagneticField(esd.fMagneticField),
1c7554f9	68	fDiamondZ(esd.fDiamondZ),
1c7554f9	69	fDiamondSig2Z(esd.fDiamondSig2Z),
d5ebf00e	70	fPeriodNumber(esd.fPeriodNumber),
694aad0c	71	fRunNumber(esd.fRunNumber),
f009b5c1	72	fRecoVersion(esd.fRecoVersion),
33fe5eb1	73	fBeamType(""),
7b649c02	74	fTriggerClasses(TObjArray(kNTriggerClasses)),
	75	fDetInDAQ(0),
	76	fDetInReco(0)
d5ebf00e	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];
f009b5c1	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	}
8d218603	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	}
b671618d	93
	94	for (int ib=2;ib--;) for (int it=2;it--;) fMeanBeamInt[ib][it] = esd.fMeanBeamInt[ib][it];
	95
428557af	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	}
d443e5e9	102	for (Int_t i=0; i<kT0spreadSize;i++) fT0spread[i]=esd.fT0spread[i];
d443e5e9	103
d5ebf00e	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;
8d218603	113	fPeriodNumber=esd.fPeriodNumber;
	114	fRecoVersion=esd.fRecoVersion;
	115	fMagneticField=esd.fMagneticField;
1c7554f9	116	fDiamondZ=esd.fDiamondZ;
1c7554f9	117	fDiamondSig2Z=esd.fDiamondSig2Z;
33fe5eb1	118	fBeamType = esd.fBeamType;
	119	fCurrentL3 = esd.fCurrentL3;
	120	fCurrentDip = esd.fCurrentDip;
	121	fBeamEnergy = esd.fBeamEnergy;
8d218603	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
7b649c02	130	fDetInDAQ = esd.fDetInDAQ;
	131	fDetInReco = esd.fDetInReco;
	132
b671618d	133	for (int ib=2;ib--;) for (int it=2;it--;) fMeanBeamInt[ib][it] = esd.fMeanBeamInt[ib][it];
b671618d	134
8d218603	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	}
428557af	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	}
d5ebf00e	148	}
d443e5e9	149	for (Int_t i=0; i<kT0spreadSize;i++) fT0spread[i]=esd.fT0spread[i];
d5ebf00e	150	return *this;
	151	}
	152
732a24fe	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
8d218603	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	}
428557af	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	}
8d218603	179	}
8d218603	180
d5ebf00e	181	void AliESDRun::SetDiamond(const AliESDVertex *vertex) {
	182	// set the interaction diamond
	183	fDiamondXY[0]=vertex->GetXv();
	184	fDiamondXY[1]=vertex->GetYv();
1c7554f9	185	fDiamondZ=vertex->GetZv();
d5ebf00e	186	Double32_t cov[6];
	187	vertex->GetCovMatrix(cov);
	188	fDiamondCovXY[0]=cov[0];
	189	fDiamondCovXY[1]=cov[1];
	190	fDiamondCovXY[2]=cov[2];
1c7554f9	191	fDiamondSig2Z=cov[5];
d5ebf00e	192	}
	193
	194
	195	//______________________________________________________________________________
	196	void AliESDRun::Print(const Option_t *) const
	197	{
	198	// Print some data members
1c7554f9	199	printf("Mean vertex in RUN %d: X=%.4f Y=%.4f Z=%.4f cm\n",
1c7554f9	200	GetRunNumber(),GetDiamondX(),GetDiamondY(),GetDiamondZ());
33fe5eb1	201	printf("Beam Type: %s, Energy: %.1f GeV\n",fBeamType.IsNull() ? "N/A":fBeamType.Data(),fBeamEnergy);
	202	printf("Magnetic field in IP= %f T \| Currents: L3:%+.1f Dipole:%+.1f %s\n",
	203	GetMagneticField(),fCurrentL3,fCurrentDip,TestBit(kUniformBMap) ? "(Uniform)":"");
d5ebf00e	204	printf("Event from reconstruction version %d \n",fRecoVersion);
f009b5c1	205
	206	printf("List of active trigger classes: ");
	207	for(Int_t i = 0; i < kNTriggerClasses; i++) {
	208	TNamed str = (TNamed )((fTriggerClasses).At(i));
384e7a60	209	if (str) printf("%s ",str->GetName());
f009b5c1	210	}
b671618d	211	printf("Mean intenstity for interacting : beam1:%+.3e beam2:%+.3e\n",fMeanBeamInt[0][0],fMeanBeamInt[1][0]);
b671618d	212	printf("Mean intenstity for non-intecting : beam1:%+.3e beam2:%+.3e\n",fMeanBeamInt[0][1],fMeanBeamInt[1][1]);
f009b5c1	213	printf("\n");
d5ebf00e	214	}
	215
	216	void AliESDRun::Reset()
	217	{
	218	// reset data members
	219	fRunNumber = 0;
	220	fPeriodNumber = 0;
	221	fRecoVersion = 0;
	222	fMagneticField = 0;
11be4f1c	223	fCurrentL3 = 0;
	224	fCurrentDip = 0;
	225	fBeamEnergy = 0;
	226	fBeamType = "";
5cf76849	227	ResetBit(kBInfoStored\|kUniformBMap\|kConvSqrtSHalfGeV);
d5ebf00e	228	for (Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
a2dedd16	229	fDiamondCovXY[0]=fDiamondCovXY[2]=3.*3.;
a2dedd16	230	fDiamondCovXY[1]=0.;
1c7554f9	231	fDiamondZ=0.;
1c7554f9	232	fDiamondSig2Z=10.*10.;
f009b5c1	233	fTriggerClasses.Clear();
7b649c02	234	fDetInDAQ = 0;
7b649c02	235	fDetInReco = 0;
f009b5c1	236	}
	237
	238	//______________________________________________________________________________
	239	void AliESDRun::SetTriggerClass(const char*name, Int_t index)
	240	{
	241	// Fill the trigger class name
	242	// into the corresponding array
	243	if (index >= kNTriggerClasses \|\| index < 0) {
	244	AliError(Form("Index (%d) is outside the allowed range (0,49)!",index));
	245	return;
	246	}
	247
	248	fTriggerClasses.AddAt(new TNamed(name,NULL),index);
	249	}
	250
	251	//______________________________________________________________________________
	252	const char* AliESDRun::GetTriggerClass(Int_t index) const
	253	{
	254	// Get the trigger class name at
	255	// specified position in the trigger mask
	256	TNamed trclass = (TNamed )fTriggerClasses.At(index);
	257	if (trclass)
	258	return trclass->GetName();
	259	else
	260	return "";
	261	}
	262
	263	//______________________________________________________________________________
	264	TString AliESDRun::GetActiveTriggerClasses() const
	265	{
	266	// Construct and return
	267	// the list of trigger classes
	268	// which are present in the run
	269	TString trclasses;
	270	for(Int_t i = 0; i < kNTriggerClasses; i++) {
	271	TNamed str = (TNamed )((fTriggerClasses).At(i));
	272	if (str) {
	273	trclasses += " ";
	274	trclasses += str->GetName();
	275	trclasses += " ";
	276	}
	277	}
	278
	279	return trclasses;
	280	}
	281
	282	//______________________________________________________________________________
	283	TString AliESDRun::GetFiredTriggerClasses(ULong64_t mask) const
	284	{
	285	// Constructs and returns the
	286	// list of trigger classes that
	287	// have been fired. Uses the trigger
	288	// class mask as an argument.
	289	TString trclasses;
	290	for(Int_t i = 0; i < kNTriggerClasses; i++) {
a62d86d6	291	if (mask & (1ull << i)) {
f009b5c1	292	TNamed str = (TNamed )((fTriggerClasses).At(i));
	293	if (str) {
	294	trclasses += " ";
	295	trclasses += str->GetName();
	296	trclasses += " ";
	297	}
	298	}
	299	}
	300
	301	return trclasses;
d5ebf00e	302	}
d5ebf00e	303
f009b5c1	304	//______________________________________________________________________________
	305	Bool_t AliESDRun::IsTriggerClassFired(ULong64_t mask, const char *name) const
	306	{
	307	// Checks if the trigger class
	308	// identified by 'name' has been
	309	// fired. Uses the trigger class mask.
	310
	311	TNamed trclass = (TNamed )fTriggerClasses.FindObject(name);
	312	if (!trclass) return kFALSE;
	313
	314	Int_t iclass = fTriggerClasses.IndexOf(trclass);
	315	if (iclass < 0) return kFALSE;
	316
a62d86d6	317	if (mask & (1ull << iclass))
f009b5c1	318	return kTRUE;
	319	else
	320	return kFALSE;
	321	}
33fe5eb1	322
	323	//_____________________________________________________________________________
	324	Bool_t AliESDRun::InitMagneticField() const
	325	{
	326	// Create mag field from stored information
	327	//
	328	if (!TestBit(kBInfoStored)) {
	329	AliError("No information on currents, cannot create field from run header");
	330	return kFALSE;
	331	}
	332	//
	333	if ( TGeoGlobalMagField::Instance()->IsLocked() ) {
	334	if (TGeoGlobalMagField::Instance()->GetField()->TestBit(AliMagF::kOverrideGRP)) {
	335	AliInfo("ExpertMode!!! Information on magnet currents will be ignored !");
	336	AliInfo("ExpertMode!!! Running with the externally locked B field !");
	337	return kTRUE;
	338	}
	339	else {
	340	AliInfo("Destroying existing B field instance!");
	341	delete TGeoGlobalMagField::Instance();
	342	}
	343	}
	344	//
	345	AliMagF* fld = AliMagF::CreateFieldMap(fCurrentL3,fCurrentDip,AliMagF::kConvLHC,
5cf76849	346	TestBit(kUniformBMap), GetBeamEnergy(), GetBeamType());
33fe5eb1	347	if (fld) {
	348	TGeoGlobalMagField::Instance()->SetField( fld );
	349	TGeoGlobalMagField::Instance()->Lock();
	350	AliInfo("Running with the B field constructed out of the Run Header !");
	351	return kTRUE;
	352	}
	353	else {
	354	AliError("Failed to create a B field map !");
	355	return kFALSE;
	356	}
	357	//
	358	}
d443e5e9	359
	360	//_____________________________________________________________________________
	361	void AliESDRun::SetT0spread(Int_t i,Float_t t)
	362	{
	363	//
	364	// Setting the T0 spread value at index i
	365	//
	366
	367	if ( (i>=0) && (i<kT0spreadSize)) {
	368	fT0spread[i]=t;
	369	} else {
	370	AliError(Form("Index %d out of bound",i));
	371	}
	372	return;
	373	}
	374
	375	//_____________________________________________________________________________
	376	void AliESDRun::SetT0spread(Float_t *t)
	377	{
	378	//
	379	// Setting the T0 spread values
	380	//
	381	if (t == 0x0){
	382	AliError(Form("Null pointer passed"));
	383	}
	384	else{
	385	for (Int_t i=0;i<kT0spreadSize;i++) fT0spread[i]=t[i];
	386	}
	387	return;
	388	}
	389