[u/mrichter/AliRoot.git] / STEER / 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;
}

//______________________________________________________________________________
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;
}

//______________________________________________________________________________
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 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;
}

//______________________________________________________________________________
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];
}

//______________________________________________________________________________
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];
  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));
    }
  }

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