[u/mrichter/AliRoot.git] / STEER / ESD / 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)  
{
  //
  // default ctor
  //
  for (Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
  fBeamParticle[0] = fBeamParticle[1] = 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.;
  for (Int_t it=0; it<8; it++) fCaloTriggerType[it]=0;
  for (Int_t j=0; j<64; ++j) fVZEROEqFactors[j]=-1;
}

//______________________________________________________________________________
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<2; i++) fBeamParticle[i] = esd.fBeamParticle[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];
  for (Int_t it=0; it<8; it++) fCaloTriggerType[it]=esd.fCaloTriggerType[it];
  for (Int_t j=0; j<64; ++j) fVZEROEqFactors[j]=esd.fVZEROEqFactors[j];

}

//______________________________________________________________________________
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];
    for (Int_t i=0; i<2; i++) fBeamParticle[i] = esd.fBeamParticle[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++){
      delete fPHOSMatrix[m];
      if(esd.fPHOSMatrix[m])
	fPHOSMatrix[m]=new TGeoHMatrix(*(esd.fPHOSMatrix[m])) ;
      else
	fPHOSMatrix[m]=0;
    }
	  
    for(Int_t sm=0; sm<kNEMCALMatrix; sm++){
      delete fEMCALMatrix[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];
  for (Int_t it=0; it<8; it++) fCaloTriggerType[it]=esd.fCaloTriggerType[it];
  for (Int_t j=0; j<64; ++j) fVZEROEqFactors[j]=esd.fVZEROEqFactors[j];
  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
  if (vertex) {
    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 (%d/%d - %d/%d), Energy: %.1f GeV\n",fBeamType.IsNull() ? "N/A":GetBeamType(),
	 GetBeamParticleA(0),GetBeamParticleZ(0),GetBeamParticleA(1),GetBeamParticleZ(1),
	 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.
  // Works both for first50 and next50 classes
  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;
}

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