[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),
  fNMuons(0),
  fNDimuons(0),
  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),
  fNMuons(0),
  fNDimuons(0),
  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,
			   Int_t nMuons,
			   Int_t nDimuons) :
  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),
  fNMuons(nMuons),
  fNDimuons(nDimuons),
  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),
  fNMuons(hdr.fNMuons),
  fNDimuons(hdr.fNDimuons),
  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;
    fNMuons           = hdr.fNMuons;
    fNDimuons         = hdr.fNDimuons;


    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);
  printf("number of muons         : %d\n", fNMuons);
  printf("number of dimuons       : %d\n", fNDimuons);

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