[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>
#include <TObjString.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),
  fFiredTriggers(),
  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),
  fFiredTriggers(),
  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),
  fFiredTriggers(),
  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),
  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)
{
  // 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;
    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;

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