[u/mrichter/AliRoot.git] / STEER / AOD / AliAODHeader.cxx

/**************************************************************************
 * Copyright(c) 1998-2007, 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.                  *
 **************************************************************************/

/* $Id$ */

//-------------------------------------------------------------------------
//     AOD event base class
//     Author: Markus Oldenburg, CERN
//-------------------------------------------------------------------------

#include "AliAODHeader.h"
#include "AliCentrality.h"
#include "AliEventplane.h"
#include <TGeoMatrix.h>
#include <TObjString.h>

ClassImp(AliAODHeader)

//______________________________________________________________________________
AliAODHeader::AliAODHeader() : 
  AliVHeader(),
  fMagneticField(-999.),
  fMuonMagFieldScale(-999.),
  fCentrality(-999.),
  fEventplane(-999.),
  fEventplaneMag(-999.),
  fZDCN1Energy(-999.),
  fZDCP1Energy(-999.),
  fZDCN2Energy(-999.),
  fZDCP2Energy(-999.),
  fNQTheta(0),
  fQTheta(0x0),
  fTriggerMask(0),
  fFiredTriggers(),
  fRunNumber(-999),  
  fRefMult(-999),
  fRefMultPos(-999),
  fRefMultNeg(-999),
  fNMuons(0),
  fNDimuons(0),
  fEventType(0),
  fOrbitNumber(0),
  fPeriodNumber(0),
  fBunchCrossNumber(0),
  fTriggerCluster(0), 
  fDiamondZ(0.), 
  fDiamondSig2Z(0.),
  fOfflineTrigger(0),
  fESDFileName(""),
  fEventNumberESDFile(-1),
  fL0TriggerInputs(0),
  fL1TriggerInputs(0),
  fL2TriggerInputs(0),
  fTPConlyRefMult(-1), 
  fCentralityP(0),
  fEventplaneP(0)
{
  // default constructor

  SetName("header");
  for(int j=0; j<2; j++) fZDCEMEnergy[j] = -999.;
  for(Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
  fDiamondCovXY[0]=fDiamondCovXY[2]=3.*3.;
  fDiamondCovXY[1]=0.;
  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 < 6; i++)  fITSClusters[i] = 0;
  for (Int_t j=0; j<64; ++j) fVZEROEqFactors[j]=-1;
  for (Int_t i=0; i<kT0SpreadSize;i++) fT0spread[i]=0;
}

//______________________________________________________________________________
AliAODHeader::AliAODHeader(Int_t nRun, 
			   UShort_t nBunchX,
			   UInt_t nOrbit,
			   UInt_t nPeriod,
			   const Char_t *title) :
  AliVHeader(),
  fMagneticField(-999.),
  fMuonMagFieldScale(-999.),
  fCentrality(-999.),
  fEventplane(-999.),
  fEventplaneMag(-999.),
  fZDCN1Energy(-999.),
  fZDCP1Energy(-999.),
  fZDCN2Energy(-999.),
  fZDCP2Energy(-999.),
  fNQTheta(0),
  fQTheta(0x0),
  fTriggerMask(0),
  fFiredTriggers(),
  fRunNumber(nRun),
  fRefMult(-999),
  fRefMultPos(-999),
  fRefMultNeg(-999),
  fNMuons(0),
  fNDimuons(0),
  fEventType(0),
  fOrbitNumber(nOrbit),
  fPeriodNumber(nPeriod),
  fBunchCrossNumber(nBunchX),
  fTriggerCluster(0), 
  fDiamondZ(0.), 
  fDiamondSig2Z(0.),
  fOfflineTrigger(0),
  fESDFileName(""),
  fEventNumberESDFile(-1),
  fL0TriggerInputs(0),
  fL1TriggerInputs(0),
  fL2TriggerInputs(0),
  fTPConlyRefMult(-1), 
  fCentralityP(0),
  fEventplaneP(0)
{
  // constructor

  SetName("header");
  SetTitle(title);
  for(int j=0; j<2; j++) fZDCEMEnergy[j] = -999.;
  for(Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
  fDiamondCovXY[0]=fDiamondCovXY[2]=3.*3.;
  fDiamondCovXY[1]=0.;
  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 j=0; j<64; ++j) fVZEROEqFactors[j]=-1;
  for (Int_t i=0; i<kT0SpreadSize;i++) fT0spread[i]=0;
}

//______________________________________________________________________________
AliAODHeader::AliAODHeader(Int_t nRun, 
			   UShort_t nBunchX,
			   UInt_t nOrbit,
			   UInt_t nPeriod,
			   Int_t refMult,
			   Int_t refMultPos,
			   Int_t refMultNeg,
			   Double_t magField,
			   Double_t muonMagFieldScale,
			   Double_t cent,
			   Double_t eventplane,
			   Double_t n1Energy,
			   Double_t p1Energy,
			   Double_t n2Energy,
			   Double_t p2Energy,
			   Double_t *emEnergy,
 			   ULong64_t trigMask,
			   UChar_t trigClus,
			   UInt_t evttype,
			   const Float_t *vzeroEqFactors,
			   const Char_t *title,
			   Int_t nMuons,
			   Int_t nDimuons) :
  AliVHeader(),
  fMagneticField(magField),
  fMuonMagFieldScale(muonMagFieldScale),
  fCentrality(cent),
  fEventplane(eventplane),
  fZDCN1Energy(n1Energy),
  fZDCP1Energy(p1Energy),
  fZDCN2Energy(n2Energy),
  fZDCP2Energy(p2Energy),
  fNQTheta(0),
  fQTheta(0x0),
  fTriggerMask(trigMask),
  fFiredTriggers(),
  fRunNumber(nRun),  
  fRefMult(refMult),
  fRefMultPos(refMultPos),
  fRefMultNeg(refMultNeg),
  fNMuons(nMuons),
  fNDimuons(nDimuons),
  fEventType(evttype),
  fOrbitNumber(nOrbit),
  fPeriodNumber(nPeriod),
  fBunchCrossNumber(nBunchX),
  fTriggerCluster(trigClus),
  fDiamondZ(0.), 
  fDiamondSig2Z(0.),
  fOfflineTrigger(0),
  fESDFileName(""),
  fEventNumberESDFile(-1),
  fL0TriggerInputs(0),
  fL1TriggerInputs(0),
  fL2TriggerInputs(0),
  fTPConlyRefMult(-1), 
  fCentralityP(0),
  fEventplaneP(0)
{
  // constructor

  SetName("header");
  SetTitle(title);
  for(int j=0; j<2; j++) fZDCEMEnergy[j] = emEnergy[j];
  for(Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
  fDiamondCovXY[0]=fDiamondCovXY[2]=3.*3.;
  fDiamondCovXY[1]=0.;
  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 < 6; i++)  fITSClusters[i] = 0;
  if (vzeroEqFactors) for (Int_t j=0; j<64; ++j) fVZEROEqFactors[j] = vzeroEqFactors[j];
  for (Int_t i=0; i<kT0SpreadSize;i++) fT0spread[i]=0;
}

//______________________________________________________________________________
AliAODHeader::~AliAODHeader() 
{
  // destructor
  delete fCentralityP;
  delete fEventplaneP;
  RemoveQTheta();
}

//______________________________________________________________________________
AliAODHeader::AliAODHeader(const AliAODHeader& hdr) :
  AliVHeader(hdr),
  fMagneticField(hdr.fMagneticField),
  fMuonMagFieldScale(hdr.fMuonMagFieldScale),
  fCentrality(hdr.fCentrality),
  fEventplane(hdr.fEventplane),
  fEventplaneMag(hdr.fEventplaneMag),
  fZDCN1Energy(hdr.fZDCN1Energy),
  fZDCP1Energy(hdr.fZDCP1Energy),
  fZDCN2Energy(hdr.fZDCN2Energy),
  fZDCP2Energy(hdr.fZDCP2Energy),
  fNQTheta(0),
  fQTheta(0x0),
  fTriggerMask(hdr.fTriggerMask),
  fFiredTriggers(hdr.fFiredTriggers),
  fRunNumber(hdr.fRunNumber),  
  fRefMult(hdr.fRefMult), 
  fRefMultPos(hdr.fRefMultPos), 
  fRefMultNeg(hdr.fRefMultNeg),
  fNMuons(hdr.fNMuons),
  fNDimuons(hdr.fNDimuons),
  fEventType(hdr.fEventType),
  fOrbitNumber(hdr.fOrbitNumber),
  fPeriodNumber(hdr.fPeriodNumber),
  fBunchCrossNumber(hdr.fBunchCrossNumber),
  fTriggerCluster(hdr.fTriggerCluster), 
  fDiamondZ(hdr.fDiamondZ), 
  fDiamondSig2Z(hdr.fDiamondSig2Z),
  fOfflineTrigger(hdr.fOfflineTrigger),
  fESDFileName(hdr.fESDFileName),
  fEventNumberESDFile(hdr.fEventNumberESDFile),
  fL0TriggerInputs(hdr.fL0TriggerInputs),
  fL1TriggerInputs(hdr.fL1TriggerInputs),
  fL2TriggerInputs(hdr.fL2TriggerInputs),
  fTPConlyRefMult(hdr.fTPConlyRefMult), 
  fCentralityP(new AliCentrality(*hdr.fCentralityP)),
  fEventplaneP(new AliEventplane(*hdr.fEventplaneP))
{
  // Copy constructor.
  
  SetName(hdr.fName);
  SetTitle(hdr.fTitle);
  SetQTheta(hdr.fQTheta, hdr.fNQTheta);
  SetZDCEMEnergy(hdr.fZDCEMEnergy[0], hdr.fZDCEMEnergy[1]);
  for(Int_t i=0; i<2; i++) fDiamondXY[i]=hdr.fDiamondXY[i];
  for(Int_t i=0; i<3; i++) fDiamondCovXY[i]=hdr.fDiamondCovXY[i];


  for(Int_t m=0; m<kNPHOSMatrix; m++){
      if(hdr.fPHOSMatrix[m])
	  fPHOSMatrix[m]=new TGeoHMatrix(*(hdr.fPHOSMatrix[m])) ;
      else
	  fPHOSMatrix[m]=0;
  }
  
  for(Int_t sm=0; sm<kNEMCALMatrix; sm++){
      if(hdr.fEMCALMatrix[sm])
	  fEMCALMatrix[sm]=new TGeoHMatrix(*(hdr.fEMCALMatrix[sm])) ;
      else
	  fEMCALMatrix[sm]=0;
  }
  for (Int_t i = 0; i < 6; i++)  fITSClusters[i] = hdr.fITSClusters[i];
  for (Int_t j=0; j<64; ++j) fVZEROEqFactors[j]=hdr.fVZEROEqFactors[j];
  for (Int_t i=0; i<kT0SpreadSize;i++) fT0spread[i]=hdr.fT0spread[i];

}

//______________________________________________________________________________
AliAODHeader& AliAODHeader::operator=(const AliAODHeader& hdr)
{
  // Assignment operator
  if(this!=&hdr) {
    
     AliVHeader::operator=(hdr);
    
    fMagneticField    = hdr.fMagneticField;
    fMuonMagFieldScale= hdr.fMuonMagFieldScale;
    fCentrality       = hdr.fCentrality;
    fEventplane       = hdr.fEventplane;
    fEventplaneMag    = hdr.fEventplaneMag;
    fZDCN1Energy      = hdr.fZDCN1Energy;
    fZDCP1Energy      = hdr.fZDCP1Energy;
    fZDCN2Energy      = hdr.fZDCN2Energy;
    fZDCP2Energy      = hdr.fZDCP2Energy;
    fTriggerMask      = hdr.fTriggerMask;
    fFiredTriggers    = hdr.fFiredTriggers;
    fRunNumber        = hdr.fRunNumber;
    fRefMult          = hdr.fRefMult;
    fRefMultPos       = hdr.fRefMultPos;
    fRefMultNeg       = hdr.fRefMultNeg;
    fEventType        = hdr.fEventType;
    fOrbitNumber      = hdr.fOrbitNumber;
    fPeriodNumber     = hdr.fPeriodNumber;
    fBunchCrossNumber = hdr.fBunchCrossNumber;
    fTriggerCluster   = hdr.fTriggerCluster;
    fNMuons           = hdr.fNMuons;
    fNDimuons         = hdr.fNDimuons;
    fDiamondZ         = hdr.fDiamondZ;
    fDiamondSig2Z     = hdr.fDiamondSig2Z;
    fOfflineTrigger   = hdr.fOfflineTrigger;
    fESDFileName      = hdr.fESDFileName;
    fEventNumberESDFile = hdr.fEventNumberESDFile;
    fL0TriggerInputs    = hdr.fL0TriggerInputs;
    fL1TriggerInputs    = hdr.fL1TriggerInputs;
    fL2TriggerInputs    = hdr.fL2TriggerInputs;
    fTPConlyRefMult     = hdr.fTPConlyRefMult;

    if(hdr.fEventplaneP){
      if(fEventplaneP)*fEventplaneP = *hdr.fEventplaneP;
      else fEventplaneP = new AliEventplane(*hdr.fEventplaneP);
    }

    if(hdr.fCentralityP){
      if(fCentralityP)*fCentralityP = *hdr.fCentralityP;
      else fCentralityP = new AliCentrality(*hdr.fCentralityP);
    }

    SetName(hdr.fName);
    SetTitle(hdr.fTitle);
    SetQTheta(hdr.fQTheta, hdr.fNQTheta);
    SetZDCEMEnergy(hdr.fZDCEMEnergy[0], hdr.fZDCEMEnergy[1]);
    for(Int_t i=0; i<2; i++) fDiamondXY[i]=hdr.fDiamondXY[i];
    for(Int_t i=0; i<3; i++) fDiamondCovXY[i]=hdr.fDiamondCovXY[i];

    for(Int_t m=0; m<kNPHOSMatrix; m++){
      if(hdr.fPHOSMatrix[m]){
	if(fPHOSMatrix[m])delete fPHOSMatrix[m];
	fPHOSMatrix[m]=new TGeoHMatrix(*(hdr.fPHOSMatrix[m])) ;
      }
      else
	fPHOSMatrix[m]=0;
    }
    
    for(Int_t sm=0; sm<kNEMCALMatrix; sm++){
      if(hdr.fEMCALMatrix[sm]){
	if(fEMCALMatrix[sm])delete fEMCALMatrix[sm];
	fEMCALMatrix[sm]=new TGeoHMatrix(*(hdr.fEMCALMatrix[sm])) ;
      }
      else
	fEMCALMatrix[sm]=0;
    }
    
  }

  for (Int_t i = 0; i < 6; i++)  fITSClusters[i] = hdr.fITSClusters[i];
  for (Int_t j=0; j<64; ++j) fVZEROEqFactors[j] = hdr.fVZEROEqFactors[j];
  for (Int_t i=0; i<kT0SpreadSize;i++) fT0spread[i]=hdr.fT0spread[i];

  return *this;
}

//______________________________________________________________________________
void AliAODHeader::SetQTheta(Double_t *QTheta, UInt_t size) 
{
  if (QTheta && size>0) {
    if (size != (UInt_t)fNQTheta) {
      RemoveQTheta();
      fNQTheta = size;
      fQTheta = new Double_t[fNQTheta];
    }
    
    for (Int_t i = 0; i < fNQTheta; i++) {
      fQTheta[i] = QTheta[i];
    }
  } else {
    RemoveQTheta();
  }

  return;
}

//______________________________________________________________________________
Double_t AliAODHeader::GetQTheta(UInt_t i) const
{
  if (fQTheta && i < (UInt_t)fNQTheta) {
    return fQTheta[i];
  } else {
    return -999.;
  }
}

//______________________________________________________________________________
void AliAODHeader::RemoveQTheta()
{
  delete[] fQTheta;
  fQTheta = 0x0;
  fNQTheta = 0;

  return;
}

void AliAODHeader::Clear(Option_t* /*opt*/)
{
// Clear memory
  RemoveQTheta();
  if (fCentralityP){
    delete fCentralityP;
    fCentralityP = 0;
    fCentrality = -999;
  }
  if (fEventplaneP){
    delete fEventplaneP;
    fEventplaneP = 0;
    fEventplane = -999;
    fEventplaneMag = -999.;
  }
  return;
}

//______________________________________________________________________________
void AliAODHeader::Print(Option_t* /*option*/) const 
{
  // prints event information

  printf("Run #                   : %d\n", fRunNumber);
  printf("Bunch Crossing  #       : %d\n", fBunchCrossNumber);
  printf("Orbit Number #          : %d\n", fOrbitNumber);
  printf("Period Number #         : %d\n", fPeriodNumber);
  printf("Trigger mask            : %lld\n", fTriggerMask);
  printf("Trigger cluster         : %d\n", fTriggerCluster);
  printf("Event Type              : %d\n", fEventType);
  printf("Magnetic field          : %f\n", fMagneticField);
  printf("Muon mag. field scale   : %f\n", fMuonMagFieldScale);
  
  printf("Centrality              : %f\n", fCentrality);
  printf("Event plane             : %f\n", fEventplane);
  printf("Event plane             : %f\n", fEventplaneMag);
  printf("ZDC N1 Energy           : %f\n", fZDCN1Energy);
  printf("ZDC P1 Energy           : %f\n", fZDCP1Energy);
  printf("ZDC N2 Energy           : %f\n", fZDCN2Energy);
  printf("ZDC P2 Energy           : %f\n", fZDCP2Energy);
  printf("ZDC EM1 Energy          : %f\n", fZDCEMEnergy[0]);
  printf("ZDC EM2 Energy          : %f\n", fZDCEMEnergy[1]);
  printf("ref. Multiplicity       : %d\n", fRefMult);
  printf("ref. Multiplicity (pos) : %d\n", fRefMultPos);
  printf("ref. Multiplicity (neg) : %d\n", fRefMultNeg);
  printf("number of muons         : %d\n", fNMuons);
  printf("number of dimuons       : %d\n", fNDimuons);
  printf("offline trigger         : %u\n", fOfflineTrigger);

  if (fQTheta) {
    for (UInt_t i = 0; i<(UInt_t)fNQTheta; i++) {
      printf("QTheta[%d]              : %13.3e\n", i, GetQTheta(i));
    }
  }
  printf("V0 Eq factors: ");
  for (Int_t j=0; j<64; ++j) printf(" %.3f",fVZEROEqFactors[j]);
  printf("\n");

  return;
}
Commit	Line	Data
df9db588	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"
1d7d8ba7	24	#include "AliCentrality.h"
ce7adfe9	25	#include "AliEventplane.h"
1aa76f71	26	#include <TGeoMatrix.h>
27346f69	27	#include <TObjString.h>
df9db588	28
	29	ClassImp(AliAODHeader)
	30
	31	//______________________________________________________________________________
	32	AliAODHeader::AliAODHeader() :
9ae2e5e6	33	AliVHeader(),
df9db588	34	fMagneticField(-999.),
6b6f8d32	35	fMuonMagFieldScale(-999.),
df9db588	36	fCentrality(-999.),
ce7adfe9	37	fEventplane(-999.),
c7d82ff7	38	fEventplaneMag(-999.),
6b6f8d32	39	fZDCN1Energy(-999.),
	40	fZDCP1Energy(-999.),
	41	fZDCN2Energy(-999.),
	42	fZDCP2Energy(-999.),
ff254193	43	fNQTheta(0),
ff254193	44	fQTheta(0x0),
df9db588	45	fTriggerMask(0),
27346f69	46	fFiredTriggers(),
df9db588	47	fRunNumber(-999),
	48	fRefMult(-999),
	49	fRefMultPos(-999),
	50	fRefMultNeg(-999),
dba4ebde	51	fNMuons(0),
dba4ebde	52	fNDimuons(0),
9333290e	53	fEventType(0),
	54	fOrbitNumber(0),
	55	fPeriodNumber(0),
	56	fBunchCrossNumber(0),
65b25288	57	fTriggerCluster(0),
65b25288	58	fDiamondZ(0.),
0c6c629b	59	fDiamondSig2Z(0.),
a5f7aba4	60	fOfflineTrigger(0),
	61	fESDFileName(""),
	62	fEventNumberESDFile(-1),
	63	fL0TriggerInputs(0),
	64	fL1TriggerInputs(0),
1d7d8ba7	65	fL2TriggerInputs(0),
f7ce7a37	66	fTPConlyRefMult(-1),
ce7adfe9	67	fCentralityP(0),
ce7adfe9	68	fEventplaneP(0)
df9db588	69	{
df9db588	70	// default constructor
9ae2e5e6	71
9ae2e5e6	72	SetName("header");
a85132e7	73	for(int j=0; j<2; j++) fZDCEMEnergy[j] = -999.;
613fc341	74	for(Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
	75	fDiamondCovXY[0]=fDiamondCovXY[2]=3.*3.;
	76	fDiamondCovXY[1]=0.;
1aa76f71	77	for (Int_t m=0; m<kNPHOSMatrix; m++) fPHOSMatrix[m]=NULL;
1aa76f71	78	for (Int_t sm=0; sm<kNEMCALMatrix; sm++) fEMCALMatrix[sm]=NULL;
f7ce7a37	79	for (Int_t i = 0; i < 6; i++) fITSClusters[i] = 0;
5e14e698	80	for (Int_t j=0; j<64; ++j) fVZEROEqFactors[j]=-1;
949be341	81	for (Int_t i=0; i<kT0SpreadSize;i++) fT0spread[i]=0;
df9db588	82	}
	83
	84	//______________________________________________________________________________
31fd97b2	85	AliAODHeader::AliAODHeader(Int_t nRun,
	86	UShort_t nBunchX,
	87	UInt_t nOrbit,
89cf15db	88	UInt_t nPeriod,
abfce367	89	const Char_t *title) :
9ae2e5e6	90	AliVHeader(),
df9db588	91	fMagneticField(-999.),
6b6f8d32	92	fMuonMagFieldScale(-999.),
df9db588	93	fCentrality(-999.),
ce7adfe9	94	fEventplane(-999.),
c7d82ff7	95	fEventplaneMag(-999.),
6b6f8d32	96	fZDCN1Energy(-999.),
	97	fZDCP1Energy(-999.),
	98	fZDCN2Energy(-999.),
	99	fZDCP2Energy(-999.),
ff254193	100	fNQTheta(0),
ff254193	101	fQTheta(0x0),
df9db588	102	fTriggerMask(0),
27346f69	103	fFiredTriggers(),
ff254193	104	fRunNumber(nRun),
df9db588	105	fRefMult(-999),
	106	fRefMultPos(-999),
	107	fRefMultNeg(-999),
dba4ebde	108	fNMuons(0),
dba4ebde	109	fNDimuons(0),
9333290e	110	fEventType(0),
	111	fOrbitNumber(nOrbit),
	112	fPeriodNumber(nPeriod),
	113	fBunchCrossNumber(nBunchX),
65b25288	114	fTriggerCluster(0),
65b25288	115	fDiamondZ(0.),
0c6c629b	116	fDiamondSig2Z(0.),
a5f7aba4	117	fOfflineTrigger(0),
	118	fESDFileName(""),
	119	fEventNumberESDFile(-1),
	120	fL0TriggerInputs(0),
	121	fL1TriggerInputs(0),
1d7d8ba7	122	fL2TriggerInputs(0),
f7ce7a37	123	fTPConlyRefMult(-1),
ce7adfe9	124	fCentralityP(0),
ce7adfe9	125	fEventplaneP(0)
df9db588	126	{
df9db588	127	// constructor
9ae2e5e6	128
	129	SetName("header");
	130	SetTitle(title);
a85132e7	131	for(int j=0; j<2; j++) fZDCEMEnergy[j] = -999.;
613fc341	132	for(Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
	133	fDiamondCovXY[0]=fDiamondCovXY[2]=3.*3.;
	134	fDiamondCovXY[1]=0.;
1aa76f71	135	for (Int_t m=0; m<kNPHOSMatrix; m++) fPHOSMatrix[m]=NULL;
1aa76f71	136	for (Int_t sm=0; sm<kNEMCALMatrix; sm++) fEMCALMatrix[sm]=NULL;
5e14e698	137	for (Int_t j=0; j<64; ++j) fVZEROEqFactors[j]=-1;
949be341	138	for (Int_t i=0; i<kT0SpreadSize;i++) fT0spread[i]=0;
df9db588	139	}
	140
	141	//______________________________________________________________________________
31fd97b2	142	AliAODHeader::AliAODHeader(Int_t nRun,
	143	UShort_t nBunchX,
	144	UInt_t nOrbit,
89cf15db	145	UInt_t nPeriod,
df9db588	146	Int_t refMult,
	147	Int_t refMultPos,
	148	Int_t refMultNeg,
	149	Double_t magField,
6b6f8d32	150	Double_t muonMagFieldScale,
df9db588	151	Double_t cent,
ce7adfe9	152	Double_t eventplane,
6b6f8d32	153	Double_t n1Energy,
	154	Double_t p1Energy,
	155	Double_t n2Energy,
	156	Double_t p2Energy,
a85132e7	157	Double_t *emEnergy,
6b6f8d32	158	ULong64_t trigMask,
df9db588	159	UChar_t trigClus,
df9db588	160	UInt_t evttype,
5e14e698	161	const Float_t *vzeroEqFactors,
fa8b0e56	162	const Char_t *title,
	163	Int_t nMuons,
	164	Int_t nDimuons) :
9ae2e5e6	165	AliVHeader(),
df9db588	166	fMagneticField(magField),
6b6f8d32	167	fMuonMagFieldScale(muonMagFieldScale),
df9db588	168	fCentrality(cent),
ce7adfe9	169	fEventplane(eventplane),
6b6f8d32	170	fZDCN1Energy(n1Energy),
	171	fZDCP1Energy(p1Energy),
	172	fZDCN2Energy(n2Energy),
	173	fZDCP2Energy(p2Energy),
ff254193	174	fNQTheta(0),
ff254193	175	fQTheta(0x0),
df9db588	176	fTriggerMask(trigMask),
27346f69	177	fFiredTriggers(),
df9db588	178	fRunNumber(nRun),
	179	fRefMult(refMult),
	180	fRefMultPos(refMultPos),
	181	fRefMultNeg(refMultNeg),
dba4ebde	182	fNMuons(nMuons),
dba4ebde	183	fNDimuons(nDimuons),
9333290e	184	fEventType(evttype),
	185	fOrbitNumber(nOrbit),
	186	fPeriodNumber(nPeriod),
	187	fBunchCrossNumber(nBunchX),
0c6c629b	188	fTriggerCluster(trigClus),
65b25288	189	fDiamondZ(0.),
0c6c629b	190	fDiamondSig2Z(0.),
a5f7aba4	191	fOfflineTrigger(0),
	192	fESDFileName(""),
	193	fEventNumberESDFile(-1),
	194	fL0TriggerInputs(0),
	195	fL1TriggerInputs(0),
1d7d8ba7	196	fL2TriggerInputs(0),
f7ce7a37	197	fTPConlyRefMult(-1),
ce7adfe9	198	fCentralityP(0),
ce7adfe9	199	fEventplaneP(0)
df9db588	200	{
df9db588	201	// constructor
9ae2e5e6	202
	203	SetName("header");
	204	SetTitle(title);
a85132e7	205	for(int j=0; j<2; j++) fZDCEMEnergy[j] = emEnergy[j];
613fc341	206	for(Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
	207	fDiamondCovXY[0]=fDiamondCovXY[2]=3.*3.;
	208	fDiamondCovXY[1]=0.;
1aa76f71	209	for (Int_t m=0; m<kNPHOSMatrix; m++) fPHOSMatrix[m]=NULL;
1aa76f71	210	for (Int_t sm=0; sm<kNEMCALMatrix; sm++) fEMCALMatrix[sm]=NULL;
f7ce7a37	211	for (Int_t i = 0; i < 6; i++) fITSClusters[i] = 0;
5e14e698	212	if (vzeroEqFactors) for (Int_t j=0; j<64; ++j) fVZEROEqFactors[j] = vzeroEqFactors[j];
949be341	213	for (Int_t i=0; i<kT0SpreadSize;i++) fT0spread[i]=0;
df9db588	214	}
	215
	216	//______________________________________________________________________________
	217	AliAODHeader::~AliAODHeader()
	218	{
	219	// destructor
1d7d8ba7	220	delete fCentralityP;
ce7adfe9	221	delete fEventplaneP;
ff254193	222	RemoveQTheta();
df9db588	223	}
	224
	225	//______________________________________________________________________________
	226	AliAODHeader::AliAODHeader(const AliAODHeader& hdr) :
9ae2e5e6	227	AliVHeader(hdr),
df9db588	228	fMagneticField(hdr.fMagneticField),
6b6f8d32	229	fMuonMagFieldScale(hdr.fMuonMagFieldScale),
df9db588	230	fCentrality(hdr.fCentrality),
ce7adfe9	231	fEventplane(hdr.fEventplane),
c7d82ff7	232	fEventplaneMag(hdr.fEventplaneMag),
6b6f8d32	233	fZDCN1Energy(hdr.fZDCN1Energy),
	234	fZDCP1Energy(hdr.fZDCP1Energy),
	235	fZDCN2Energy(hdr.fZDCN2Energy),
	236	fZDCP2Energy(hdr.fZDCP2Energy),
ff254193	237	fNQTheta(0),
ff254193	238	fQTheta(0x0),
df9db588	239	fTriggerMask(hdr.fTriggerMask),
27346f69	240	fFiredTriggers(hdr.fFiredTriggers),
df9db588	241	fRunNumber(hdr.fRunNumber),
	242	fRefMult(hdr.fRefMult),
	243	fRefMultPos(hdr.fRefMultPos),
	244	fRefMultNeg(hdr.fRefMultNeg),
dba4ebde	245	fNMuons(hdr.fNMuons),
dba4ebde	246	fNDimuons(hdr.fNDimuons),
9333290e	247	fEventType(hdr.fEventType),
	248	fOrbitNumber(hdr.fOrbitNumber),
	249	fPeriodNumber(hdr.fPeriodNumber),
	250	fBunchCrossNumber(hdr.fBunchCrossNumber),
80a3f83f	251	fTriggerCluster(hdr.fTriggerCluster),
80a3f83f	252	fDiamondZ(hdr.fDiamondZ),
0c6c629b	253	fDiamondSig2Z(hdr.fDiamondSig2Z),
a5f7aba4	254	fOfflineTrigger(hdr.fOfflineTrigger),
	255	fESDFileName(hdr.fESDFileName),
	256	fEventNumberESDFile(hdr.fEventNumberESDFile),
	257	fL0TriggerInputs(hdr.fL0TriggerInputs),
	258	fL1TriggerInputs(hdr.fL1TriggerInputs),
1d7d8ba7	259	fL2TriggerInputs(hdr.fL2TriggerInputs),
f7ce7a37	260	fTPConlyRefMult(hdr.fTPConlyRefMult),
ce7adfe9	261	fCentralityP(new AliCentrality(*hdr.fCentralityP)),
ce7adfe9	262	fEventplaneP(new AliEventplane(*hdr.fEventplaneP))
df9db588	263	{
df9db588	264	// Copy constructor.
9ae2e5e6	265
	266	SetName(hdr.fName);
	267	SetTitle(hdr.fTitle);
ff254193	268	SetQTheta(hdr.fQTheta, hdr.fNQTheta);
a85132e7	269	SetZDCEMEnergy(hdr.fZDCEMEnergy[0], hdr.fZDCEMEnergy[1]);
613fc341	270	for(Int_t i=0; i<2; i++) fDiamondXY[i]=hdr.fDiamondXY[i];
613fc341	271	for(Int_t i=0; i<3; i++) fDiamondCovXY[i]=hdr.fDiamondCovXY[i];
1aa76f71	272
	273
	274	for(Int_t m=0; m<kNPHOSMatrix; m++){
	275	if(hdr.fPHOSMatrix[m])
	276	fPHOSMatrix[m]=new TGeoHMatrix(*(hdr.fPHOSMatrix[m])) ;
	277	else
	278	fPHOSMatrix[m]=0;
	279	}
	280
	281	for(Int_t sm=0; sm<kNEMCALMatrix; sm++){
	282	if(hdr.fEMCALMatrix[sm])
	283	fEMCALMatrix[sm]=new TGeoHMatrix(*(hdr.fEMCALMatrix[sm])) ;
	284	else
	285	fEMCALMatrix[sm]=0;
	286	}
f7ce7a37	287	for (Int_t i = 0; i < 6; i++) fITSClusters[i] = hdr.fITSClusters[i];
5e14e698	288	for (Int_t j=0; j<64; ++j) fVZEROEqFactors[j]=hdr.fVZEROEqFactors[j];
949be341	289	for (Int_t i=0; i<kT0SpreadSize;i++) fT0spread[i]=hdr.fT0spread[i];
949be341	290
df9db588	291	}
	292
	293	//______________________________________________________________________________
	294	AliAODHeader& AliAODHeader::operator=(const AliAODHeader& hdr)
	295	{
	296	// Assignment operator
	297	if(this!=&hdr) {
6b6f8d32	298
9ae2e5e6	299	AliVHeader::operator=(hdr);
df9db588	300
31fd97b2	301	fMagneticField = hdr.fMagneticField;
6b6f8d32	302	fMuonMagFieldScale= hdr.fMuonMagFieldScale;
31fd97b2	303	fCentrality = hdr.fCentrality;
ce7adfe9	304	fEventplane = hdr.fEventplane;
c7d82ff7	305	fEventplaneMag = hdr.fEventplaneMag;
6b6f8d32	306	fZDCN1Energy = hdr.fZDCN1Energy;
	307	fZDCP1Energy = hdr.fZDCP1Energy;
	308	fZDCN2Energy = hdr.fZDCN2Energy;
	309	fZDCP2Energy = hdr.fZDCP2Energy;
31fd97b2	310	fTriggerMask = hdr.fTriggerMask;
27346f69	311	fFiredTriggers = hdr.fFiredTriggers;
31fd97b2	312	fRunNumber = hdr.fRunNumber;
	313	fRefMult = hdr.fRefMult;
	314	fRefMultPos = hdr.fRefMultPos;
	315	fRefMultNeg = hdr.fRefMultNeg;
9333290e	316	fEventType = hdr.fEventType;
	317	fOrbitNumber = hdr.fOrbitNumber;
	318	fPeriodNumber = hdr.fPeriodNumber;
	319	fBunchCrossNumber = hdr.fBunchCrossNumber;
31fd97b2	320	fTriggerCluster = hdr.fTriggerCluster;
fa8b0e56	321	fNMuons = hdr.fNMuons;
fa8b0e56	322	fNDimuons = hdr.fNDimuons;
0c6c629b	323	fDiamondZ = hdr.fDiamondZ;
	324	fDiamondSig2Z = hdr.fDiamondSig2Z;
	325	fOfflineTrigger = hdr.fOfflineTrigger;
a5f7aba4	326	fESDFileName = hdr.fESDFileName;
	327	fEventNumberESDFile = hdr.fEventNumberESDFile;
	328	fL0TriggerInputs = hdr.fL0TriggerInputs;
	329	fL1TriggerInputs = hdr.fL1TriggerInputs;
	330	fL2TriggerInputs = hdr.fL2TriggerInputs;
f7ce7a37	331	fTPConlyRefMult = hdr.fTPConlyRefMult;
72d97d56	332
	333	if(hdr.fEventplaneP){
	334	if(fEventplaneP)fEventplaneP = hdr.fEventplaneP;
	335	else fEventplaneP = new AliEventplane(*hdr.fEventplaneP);
	336	}
ff254193	337
2a77025d	338	if(hdr.fCentralityP){
	339	if(fCentralityP)fCentralityP = hdr.fCentralityP;
	340	else fCentralityP = new AliCentrality(*hdr.fCentralityP);
	341	}
	342
ff254193	343	SetName(hdr.fName);
	344	SetTitle(hdr.fTitle);
	345	SetQTheta(hdr.fQTheta, hdr.fNQTheta);
a85132e7	346	SetZDCEMEnergy(hdr.fZDCEMEnergy[0], hdr.fZDCEMEnergy[1]);
613fc341	347	for(Int_t i=0; i<2; i++) fDiamondXY[i]=hdr.fDiamondXY[i];
613fc341	348	for(Int_t i=0; i<3; i++) fDiamondCovXY[i]=hdr.fDiamondCovXY[i];
1aa76f71	349
1aa76f71	350	for(Int_t m=0; m<kNPHOSMatrix; m++){
2a77025d	351	if(hdr.fPHOSMatrix[m]){
	352	if(fPHOSMatrix[m])delete fPHOSMatrix[m];
	353	fPHOSMatrix[m]=new TGeoHMatrix(*(hdr.fPHOSMatrix[m])) ;
	354	}
	355	else
	356	fPHOSMatrix[m]=0;
1aa76f71	357	}
	358
	359	for(Int_t sm=0; sm<kNEMCALMatrix; sm++){
2a77025d	360	if(hdr.fEMCALMatrix[sm]){
	361	if(fEMCALMatrix[sm])delete fEMCALMatrix[sm];
	362	fEMCALMatrix[sm]=new TGeoHMatrix(*(hdr.fEMCALMatrix[sm])) ;
	363	}
	364	else
	365	fEMCALMatrix[sm]=0;
	366	}
	367
df9db588	368	}
df9db588	369
f7ce7a37	370	for (Int_t i = 0; i < 6; i++) fITSClusters[i] = hdr.fITSClusters[i];
5e14e698	371	for (Int_t j=0; j<64; ++j) fVZEROEqFactors[j] = hdr.fVZEROEqFactors[j];
949be341	372	for (Int_t i=0; i<kT0SpreadSize;i++) fT0spread[i]=hdr.fT0spread[i];
949be341	373
df9db588	374	return *this;
	375	}
	376
ff254193	377	//______________________________________________________________________________
	378	void AliAODHeader::SetQTheta(Double_t *QTheta, UInt_t size)
	379	{
	380	if (QTheta && size>0) {
	381	if (size != (UInt_t)fNQTheta) {
	382	RemoveQTheta();
	383	fNQTheta = size;
	384	fQTheta = new Double_t[fNQTheta];
	385	}
	386
	387	for (Int_t i = 0; i < fNQTheta; i++) {
	388	fQTheta[i] = QTheta[i];
	389	}
	390	} else {
	391	RemoveQTheta();
	392	}
	393
	394	return;
	395	}
	396
	397	//______________________________________________________________________________
	398	Double_t AliAODHeader::GetQTheta(UInt_t i) const
	399	{
	400	if (fQTheta && i < (UInt_t)fNQTheta) {
	401	return fQTheta[i];
	402	} else {
	403	return -999.;
	404	}
	405	}
	406
	407	//______________________________________________________________________________
	408	void AliAODHeader::RemoveQTheta()
	409	{
	410	delete[] fQTheta;
	411	fQTheta = 0x0;
	412	fNQTheta = 0;
	413
	414	return;
	415	}
	416
99dbf027	417	void AliAODHeader::Clear(Option_t* /opt/)
99dbf027	418	{
5e6a3170	419	// Clear memory
99dbf027	420	RemoveQTheta();
75a996ab	421	if (fCentralityP){
	422	delete fCentralityP;
	423	fCentralityP = 0;
	424	fCentrality = -999;
	425	}
ce7adfe9	426	if (fEventplaneP){
	427	delete fEventplaneP;
	428	fEventplaneP = 0;
	429	fEventplane = -999;
c7d82ff7	430	fEventplaneMag = -999.;
ce7adfe9	431	}
99dbf027	432	return;
	433	}
	434
df9db588	435	//______________________________________________________________________________
	436	void AliAODHeader::Print(Option_t* /option/) const
	437	{
	438	// prints event information
	439
df9db588	440	printf("Run # : %d\n", fRunNumber);
31fd97b2	441	printf("Bunch Crossing # : %d\n", fBunchCrossNumber);
31fd97b2	442	printf("Orbit Number # : %d\n", fOrbitNumber);
89cf15db	443	printf("Period Number # : %d\n", fPeriodNumber);
df9db588	444	printf("Trigger mask : %lld\n", fTriggerMask);
	445	printf("Trigger cluster : %d\n", fTriggerCluster);
	446	printf("Event Type : %d\n", fEventType);
	447	printf("Magnetic field : %f\n", fMagneticField);
6b6f8d32	448	printf("Muon mag. field scale : %f\n", fMuonMagFieldScale);
df9db588	449
df9db588	450	printf("Centrality : %f\n", fCentrality);
ce7adfe9	451	printf("Event plane : %f\n", fEventplane);
c7d82ff7	452	printf("Event plane : %f\n", fEventplaneMag);
6b6f8d32	453	printf("ZDC N1 Energy : %f\n", fZDCN1Energy);
	454	printf("ZDC P1 Energy : %f\n", fZDCP1Energy);
	455	printf("ZDC N2 Energy : %f\n", fZDCN2Energy);
	456	printf("ZDC P2 Energy : %f\n", fZDCP2Energy);
a85132e7	457	printf("ZDC EM1 Energy : %f\n", fZDCEMEnergy[0]);
a85132e7	458	printf("ZDC EM2 Energy : %f\n", fZDCEMEnergy[1]);
df9db588	459	printf("ref. Multiplicity : %d\n", fRefMult);
	460	printf("ref. Multiplicity (pos) : %d\n", fRefMultPos);
	461	printf("ref. Multiplicity (neg) : %d\n", fRefMultNeg);
fa8b0e56	462	printf("number of muons : %d\n", fNMuons);
fa8b0e56	463	printf("number of dimuons : %d\n", fNDimuons);
0c6c629b	464	printf("offline trigger : %u\n", fOfflineTrigger);
df9db588	465
ff254193	466	if (fQTheta) {
ff254193	467	for (UInt_t i = 0; i<(UInt_t)fNQTheta; i++) {
d067f357	468	printf("QTheta[%d] : %13.3e\n", i, GetQTheta(i));
ff254193	469	}
ff254193	470	}
5e14e698	471	printf("V0 Eq factors: ");
	472	for (Int_t j=0; j<64; ++j) printf(" %.3f",fVZEROEqFactors[j]);
	473	printf("\n");
ff254193	474
ff254193	475	return;
df9db588	476	}