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