[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 <TGeoMatrix.h>

ClassImp(AliAODHeader)

//______________________________________________________________________________
AliAODHeader::AliAODHeader() : 
  AliVHeader(),
  fMagneticField(-999.),
  fMuonMagFieldScale(-999.),
  fCentrality(-999.),
  fZDCN1Energy(-999.),
  fZDCP1Energy(-999.),
  fZDCN2Energy(-999.),
  fZDCP2Energy(-999.),
  fNQTheta(0),
  fQTheta(0x0),
  fTriggerMask(0),
  fRunNumber(-999),  
  fRefMult(-999),
  fRefMultPos(-999),
  fRefMultNeg(-999),
  fEventType(0),
  fOrbitNumber(0),
  fPeriodNumber(0),
  fBunchCrossNumber(0),
  fTriggerCluster(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;
}

//______________________________________________________________________________
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.),
  fZDCN1Energy(-999.),
  fZDCP1Energy(-999.),
  fZDCN2Energy(-999.),
  fZDCP2Energy(-999.),
  fNQTheta(0),
  fQTheta(0x0),
  fTriggerMask(0),
  fRunNumber(nRun),
  fRefMult(-999),
  fRefMultPos(-999),
  fRefMultNeg(-999),
  fEventType(0),
  fOrbitNumber(nOrbit),
  fPeriodNumber(nPeriod),
  fBunchCrossNumber(nBunchX),
  fTriggerCluster(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 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) :
  AliVHeader(),
  fMagneticField(magField),
  fMuonMagFieldScale(muonMagFieldScale),
  fCentrality(cent),
  fZDCN1Energy(n1Energy),
  fZDCP1Energy(p1Energy),
  fZDCN2Energy(n2Energy),
  fZDCP2Energy(p2Energy),
  fNQTheta(0),
  fQTheta(0x0),
  fTriggerMask(trigMask),
  fRunNumber(nRun),  
  fRefMult(refMult),
  fRefMultPos(refMultPos),
  fRefMultNeg(refMultNeg),
  fEventType(evttype),
  fOrbitNumber(nOrbit),
  fPeriodNumber(nPeriod),
  fBunchCrossNumber(nBunchX),
  fTriggerCluster(trigClus)
{
  // 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;
}

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

//______________________________________________________________________________
AliAODHeader::AliAODHeader(const AliAODHeader& hdr) :
  AliVHeader(hdr),
  fMagneticField(hdr.fMagneticField),
  fMuonMagFieldScale(hdr.fMuonMagFieldScale),
  fCentrality(hdr.fCentrality),
  fZDCN1Energy(hdr.fZDCN1Energy),
  fZDCP1Energy(hdr.fZDCP1Energy),
  fZDCN2Energy(hdr.fZDCN2Energy),
  fZDCP2Energy(hdr.fZDCP2Energy),
  fNQTheta(0),
  fQTheta(0x0),
  fTriggerMask(hdr.fTriggerMask),
  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)
{
  // 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;
  }

}

//______________________________________________________________________________
AliAODHeader& AliAODHeader::operator=(const AliAODHeader& hdr)
{
  // Assignment operator
  if(this!=&hdr) {
    
     AliVHeader::operator=(hdr);
    
    fMagneticField    = hdr.fMagneticField;
    fMuonMagFieldScale= hdr.fMuonMagFieldScale;
    fCentrality       = hdr.fCentrality;
    fZDCN1Energy      = hdr.fZDCN1Energy;
    fZDCP1Energy      = hdr.fZDCP1Energy;
    fZDCN2Energy      = hdr.fZDCN2Energy;
    fZDCP2Energy      = hdr.fZDCP2Energy;
    fTriggerMask      = hdr.fTriggerMask;
    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;

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

  }


  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::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("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);

  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
	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"
	24	#include <TGeoMatrix.h>
	25
	26	ClassImp(AliAODHeader)
	27
	28	//______________________________________________________________________________
	29	AliAODHeader::AliAODHeader() :
	30	AliVHeader(),
	31	fMagneticField(-999.),
	32	fMuonMagFieldScale(-999.),
	33	fCentrality(-999.),
	34	fZDCN1Energy(-999.),
	35	fZDCP1Energy(-999.),
	36	fZDCN2Energy(-999.),
	37	fZDCP2Energy(-999.),
	38	fNQTheta(0),
	39	fQTheta(0x0),
	40	fTriggerMask(0),
	41	fRunNumber(-999),
	42	fRefMult(-999),
	43	fRefMultPos(-999),
	44	fRefMultNeg(-999),
	45	fEventType(0),
	46	fOrbitNumber(0),
	47	fPeriodNumber(0),
	48	fBunchCrossNumber(0),
	49	fTriggerCluster(0)
	50	{
	51	// default constructor
	52
	53	SetName("header");
	54	for(int j=0; j<2; j++) fZDCEMEnergy[j] = -999.;
	55	for(Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
	56	fDiamondCovXY[0]=fDiamondCovXY[2]=3.*3.;
	57	fDiamondCovXY[1]=0.;
	58	for (Int_t m=0; m<kNPHOSMatrix; m++) fPHOSMatrix[m]=NULL;
	59	for (Int_t sm=0; sm<kNEMCALMatrix; sm++) fEMCALMatrix[sm]=NULL;
	60	}
	61
	62	//______________________________________________________________________________
	63	AliAODHeader::AliAODHeader(Int_t nRun,
	64	UShort_t nBunchX,
	65	UInt_t nOrbit,
	66	UInt_t nPeriod,
	67	const Char_t *title) :
	68	AliVHeader(),
	69	fMagneticField(-999.),
	70	fMuonMagFieldScale(-999.),
	71	fCentrality(-999.),
	72	fZDCN1Energy(-999.),
	73	fZDCP1Energy(-999.),
	74	fZDCN2Energy(-999.),
	75	fZDCP2Energy(-999.),
	76	fNQTheta(0),
	77	fQTheta(0x0),
	78	fTriggerMask(0),
	79	fRunNumber(nRun),
	80	fRefMult(-999),
	81	fRefMultPos(-999),
	82	fRefMultNeg(-999),
	83	fEventType(0),
	84	fOrbitNumber(nOrbit),
	85	fPeriodNumber(nPeriod),
	86	fBunchCrossNumber(nBunchX),
	87	fTriggerCluster(0)
	88	{
	89	// constructor
	90
	91	SetName("header");
	92	SetTitle(title);
	93	for(int j=0; j<2; j++) fZDCEMEnergy[j] = -999.;
	94	for(Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
	95	fDiamondCovXY[0]=fDiamondCovXY[2]=3.*3.;
	96	fDiamondCovXY[1]=0.;
	97	for (Int_t m=0; m<kNPHOSMatrix; m++) fPHOSMatrix[m]=NULL;
	98	for (Int_t sm=0; sm<kNEMCALMatrix; sm++) fEMCALMatrix[sm]=NULL;
	99	}
	100
	101	//______________________________________________________________________________
	102	AliAODHeader::AliAODHeader(Int_t nRun,
	103	UShort_t nBunchX,
	104	UInt_t nOrbit,
	105	UInt_t nPeriod,
	106	Int_t refMult,
	107	Int_t refMultPos,
	108	Int_t refMultNeg,
	109	Double_t magField,
	110	Double_t muonMagFieldScale,
	111	Double_t cent,
	112	Double_t n1Energy,
	113	Double_t p1Energy,
	114	Double_t n2Energy,
	115	Double_t p2Energy,
	116	Double_t *emEnergy,
	117	ULong64_t trigMask,
	118	UChar_t trigClus,
	119	UInt_t evttype,
	120	const Char_t *title) :
	121	AliVHeader(),
	122	fMagneticField(magField),
	123	fMuonMagFieldScale(muonMagFieldScale),
	124	fCentrality(cent),
	125	fZDCN1Energy(n1Energy),
	126	fZDCP1Energy(p1Energy),
	127	fZDCN2Energy(n2Energy),
	128	fZDCP2Energy(p2Energy),
	129	fNQTheta(0),
	130	fQTheta(0x0),
	131	fTriggerMask(trigMask),
	132	fRunNumber(nRun),
	133	fRefMult(refMult),
	134	fRefMultPos(refMultPos),
	135	fRefMultNeg(refMultNeg),
	136	fEventType(evttype),
	137	fOrbitNumber(nOrbit),
	138	fPeriodNumber(nPeriod),
	139	fBunchCrossNumber(nBunchX),
	140	fTriggerCluster(trigClus)
	141	{
	142	// constructor
	143
	144	SetName("header");
	145	SetTitle(title);
	146	for(int j=0; j<2; j++) fZDCEMEnergy[j] = emEnergy[j];
	147	for(Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
	148	fDiamondCovXY[0]=fDiamondCovXY[2]=3.*3.;
	149	fDiamondCovXY[1]=0.;
	150	for (Int_t m=0; m<kNPHOSMatrix; m++) fPHOSMatrix[m]=NULL;
	151	for (Int_t sm=0; sm<kNEMCALMatrix; sm++) fEMCALMatrix[sm]=NULL;
	152	}
	153
	154	//______________________________________________________________________________
	155	AliAODHeader::~AliAODHeader()
	156	{
	157	// destructor
	158
	159	RemoveQTheta();
	160	}
	161
	162	//______________________________________________________________________________
	163	AliAODHeader::AliAODHeader(const AliAODHeader& hdr) :
	164	AliVHeader(hdr),
	165	fMagneticField(hdr.fMagneticField),
	166	fMuonMagFieldScale(hdr.fMuonMagFieldScale),
	167	fCentrality(hdr.fCentrality),
	168	fZDCN1Energy(hdr.fZDCN1Energy),
	169	fZDCP1Energy(hdr.fZDCP1Energy),
	170	fZDCN2Energy(hdr.fZDCN2Energy),
	171	fZDCP2Energy(hdr.fZDCP2Energy),
	172	fNQTheta(0),
	173	fQTheta(0x0),
	174	fTriggerMask(hdr.fTriggerMask),
	175	fRunNumber(hdr.fRunNumber),
	176	fRefMult(hdr.fRefMult),
	177	fRefMultPos(hdr.fRefMultPos),
	178	fRefMultNeg(hdr.fRefMultNeg),
	179	fEventType(hdr.fEventType),
	180	fOrbitNumber(hdr.fOrbitNumber),
	181	fPeriodNumber(hdr.fPeriodNumber),
	182	fBunchCrossNumber(hdr.fBunchCrossNumber),
	183	fTriggerCluster(hdr.fTriggerCluster)
	184	{
	185	// Copy constructor.
	186
	187	SetName(hdr.fName);
	188	SetTitle(hdr.fTitle);
	189	SetQTheta(hdr.fQTheta, hdr.fNQTheta);
	190	SetZDCEMEnergy(hdr.fZDCEMEnergy[0], hdr.fZDCEMEnergy[1]);
	191	for(Int_t i=0; i<2; i++) fDiamondXY[i]=hdr.fDiamondXY[i];
	192	for(Int_t i=0; i<3; i++) fDiamondCovXY[i]=hdr.fDiamondCovXY[i];
	193
	194
	195	for(Int_t m=0; m<kNPHOSMatrix; m++){
	196	if(hdr.fPHOSMatrix[m])
	197	fPHOSMatrix[m]=new TGeoHMatrix(*(hdr.fPHOSMatrix[m])) ;
	198	else
	199	fPHOSMatrix[m]=0;
	200	}
	201
	202	for(Int_t sm=0; sm<kNEMCALMatrix; sm++){
	203	if(hdr.fEMCALMatrix[sm])
	204	fEMCALMatrix[sm]=new TGeoHMatrix(*(hdr.fEMCALMatrix[sm])) ;
	205	else
	206	fEMCALMatrix[sm]=0;
	207	}
	208
	209	}
	210
	211	//______________________________________________________________________________
	212	AliAODHeader& AliAODHeader::operator=(const AliAODHeader& hdr)
	213	{
	214	// Assignment operator
	215	if(this!=&hdr) {
	216
	217	AliVHeader::operator=(hdr);
	218
	219	fMagneticField = hdr.fMagneticField;
	220	fMuonMagFieldScale= hdr.fMuonMagFieldScale;
	221	fCentrality = hdr.fCentrality;
	222	fZDCN1Energy = hdr.fZDCN1Energy;
	223	fZDCP1Energy = hdr.fZDCP1Energy;
	224	fZDCN2Energy = hdr.fZDCN2Energy;
	225	fZDCP2Energy = hdr.fZDCP2Energy;
	226	fTriggerMask = hdr.fTriggerMask;
	227	fRunNumber = hdr.fRunNumber;
	228	fRefMult = hdr.fRefMult;
	229	fRefMultPos = hdr.fRefMultPos;
	230	fRefMultNeg = hdr.fRefMultNeg;
	231	fEventType = hdr.fEventType;
	232	fOrbitNumber = hdr.fOrbitNumber;
	233	fPeriodNumber = hdr.fPeriodNumber;
	234	fBunchCrossNumber = hdr.fBunchCrossNumber;
	235	fTriggerCluster = hdr.fTriggerCluster;
	236
	237	SetName(hdr.fName);
	238	SetTitle(hdr.fTitle);
	239	SetQTheta(hdr.fQTheta, hdr.fNQTheta);
	240	SetZDCEMEnergy(hdr.fZDCEMEnergy[0], hdr.fZDCEMEnergy[1]);
	241	for(Int_t i=0; i<2; i++) fDiamondXY[i]=hdr.fDiamondXY[i];
	242	for(Int_t i=0; i<3; i++) fDiamondCovXY[i]=hdr.fDiamondCovXY[i];
	243
	244	for(Int_t m=0; m<kNPHOSMatrix; m++){
	245	if(hdr.fPHOSMatrix[m])
	246	fPHOSMatrix[m]=new TGeoHMatrix(*(hdr.fPHOSMatrix[m])) ;
	247	else
	248	fPHOSMatrix[m]=0;
	249	}
	250
	251	for(Int_t sm=0; sm<kNEMCALMatrix; sm++){
	252	if(hdr.fEMCALMatrix[sm])
	253	fEMCALMatrix[sm]=new TGeoHMatrix(*(hdr.fEMCALMatrix[sm])) ;
	254	else
	255	fEMCALMatrix[sm]=0;
	256	}
	257
	258	}
	259
	260
	261	return *this;
	262	}
	263
	264	//______________________________________________________________________________
	265	void AliAODHeader::SetQTheta(Double_t *QTheta, UInt_t size)
	266	{
	267	if (QTheta && size>0) {
	268	if (size != (UInt_t)fNQTheta) {
	269	RemoveQTheta();
	270	fNQTheta = size;
	271	fQTheta = new Double_t[fNQTheta];
	272	}
	273
	274	for (Int_t i = 0; i < fNQTheta; i++) {
	275	fQTheta[i] = QTheta[i];
	276	}
	277	} else {
	278	RemoveQTheta();
	279	}
	280
	281	return;
	282	}
	283
	284	//______________________________________________________________________________
	285	Double_t AliAODHeader::GetQTheta(UInt_t i) const
	286	{
	287	if (fQTheta && i < (UInt_t)fNQTheta) {
	288	return fQTheta[i];
	289	} else {
	290	return -999.;
	291	}
	292	}
	293
	294	//______________________________________________________________________________
	295	void AliAODHeader::RemoveQTheta()
	296	{
	297	delete[] fQTheta;
	298	fQTheta = 0x0;
	299	fNQTheta = 0;
	300
	301	return;
	302	}
	303
	304	//______________________________________________________________________________
	305	void AliAODHeader::Print(Option_t* /option/) const
	306	{
	307	// prints event information
	308
	309	printf("Run # : %d\n", fRunNumber);
	310	printf("Bunch Crossing # : %d\n", fBunchCrossNumber);
	311	printf("Orbit Number # : %d\n", fOrbitNumber);
	312	printf("Period Number # : %d\n", fPeriodNumber);
	313	printf("Trigger mask : %lld\n", fTriggerMask);
	314	printf("Trigger cluster : %d\n", fTriggerCluster);
	315	printf("Event Type : %d\n", fEventType);
	316	printf("Magnetic field : %f\n", fMagneticField);
	317	printf("Muon mag. field scale : %f\n", fMuonMagFieldScale);
	318
	319	printf("Centrality : %f\n", fCentrality);
	320	printf("ZDC N1 Energy : %f\n", fZDCN1Energy);
	321	printf("ZDC P1 Energy : %f\n", fZDCP1Energy);
	322	printf("ZDC N2 Energy : %f\n", fZDCN2Energy);
	323	printf("ZDC P2 Energy : %f\n", fZDCP2Energy);
	324	printf("ZDC EM1 Energy : %f\n", fZDCEMEnergy[0]);
	325	printf("ZDC EM2 Energy : %f\n", fZDCEMEnergy[1]);
	326	printf("ref. Multiplicity : %d\n", fRefMult);
	327	printf("ref. Multiplicity (pos) : %d\n", fRefMultPos);
	328	printf("ref. Multiplicity (neg) : %d\n", fRefMultNeg);
	329
	330	if (fQTheta) {
	331	for (UInt_t i = 0; i<(UInt_t)fNQTheta; i++) {
	332	printf("QTheta[%d] : %13.3e\n", i, GetQTheta(i));
	333	}
	334	}
	335
	336	return;
	337	}