[u/mrichter/AliRoot.git] / STEER / AliAODCaloCluster.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 calorimeter cluster class (for PHOS and EMCAL)
//     Author: Markus Oldenburg, CERN
//-------------------------------------------------------------------------

#include <TLorentzVector.h>
#include "AliAODCaloCluster.h"

ClassImp(AliAODCaloCluster)

//______________________________________________________________________________
AliAODCaloCluster::AliAODCaloCluster() : 
  AliAODCluster(),
  fDistToBadChannel(-999.),
  fDispersion(-1),
  fM20(0.),
  fM02(0.),
  fEmcCpvDistance(-999.),
  fNExMax(0), 
  fTOF(0.),
  fTracksMatched(),
  fNCells(0),
  fCellsAbsId(),
  fCellsAmpFraction()
{
  // default constructor

}

//______________________________________________________________________________
AliAODCaloCluster::AliAODCaloCluster(Int_t id,
				     UInt_t nLabel,
				     Int_t *label, 
				     Double_t energy,
				     Double_t x[3],
				     Double_t pid[13],
				     Char_t ttype,
				     UInt_t selectInfo) :
  AliAODCluster(id, nLabel, label, energy, x, pid, ttype, selectInfo),
  fDistToBadChannel(-999.),
  fDispersion(-1),
  fM20(0.),
  fM02(0.),
  fEmcCpvDistance(-999.),
  fNExMax(0),
  fTOF(0.),
  fTracksMatched(),
  fNCells(0),
  fCellsAbsId(),
  fCellsAmpFraction()
{
  // constructor

}

//______________________________________________________________________________
AliAODCaloCluster::AliAODCaloCluster(Int_t id,
				     UInt_t nLabel,
				     Int_t *label, 
				     Float_t energy,
				     Float_t x[3],
				     Float_t pid[13],
				     Char_t ttype,
				     UInt_t selectInfo) :
  AliAODCluster(id, nLabel, label, energy, x, pid, ttype, selectInfo),
  fDistToBadChannel(-999.),
  fDispersion(-1),
  fM20(0.),
  fM02(0.),
  fEmcCpvDistance(-999.),
  fNExMax(0),
  fTOF(0.),
  fTracksMatched(),
  fNCells(0),
  fCellsAbsId(),
  fCellsAmpFraction()
{
  // constructor
}


//______________________________________________________________________________
AliAODCaloCluster::~AliAODCaloCluster() 
{
  // destructor
  if(fCellsAmpFraction) delete[] fCellsAmpFraction; fCellsAmpFraction=0;
  if(fCellsAbsId) delete[] fCellsAbsId;  fCellsAbsId = 0;
}


//______________________________________________________________________________
AliAODCaloCluster::AliAODCaloCluster(const AliAODCaloCluster& clus) :
  AliAODCluster(clus),
  fDistToBadChannel(clus.fDistToBadChannel),
  fDispersion(clus.fDispersion),
  fM20(clus.fM20),
  fM02(clus.fM02),
  fEmcCpvDistance(clus.fEmcCpvDistance),
  fNExMax(clus.fNExMax),
  fTOF(clus.fTOF),
  fTracksMatched(clus.fTracksMatched),
  fNCells(clus.fNCells),
  fCellsAbsId(),
  fCellsAmpFraction()
{
  // Copy constructor

  if (clus.fNCells > 0) {
    
    if(clus.fCellsAbsId){
      fCellsAbsId = new UShort_t[clus.fNCells];
      for (Int_t i=0; i<clus.fNCells; i++)
	fCellsAbsId[i]=clus.fCellsAbsId[i];
    }
    
    if(clus.fCellsAmpFraction){
      fCellsAmpFraction = new Double32_t[clus.fNCells];
      for (Int_t i=0; i<clus.fNCells; i++)
	fCellsAmpFraction[i]=clus.fCellsAmpFraction[i];
    }
    
  }
  
}

//______________________________________________________________________________
AliAODCaloCluster& AliAODCaloCluster::operator=(const AliAODCaloCluster& clus)
{
  // Assignment operator
  if(this!=&clus) {

    AliAODCluster::operator=(clus);

    fDistToBadChannel = clus.fDistToBadChannel;
    fDispersion = clus.fDispersion;
    fM20 = clus.fM20;
    fM02 = clus.fM02;
    fEmcCpvDistance = clus.fEmcCpvDistance;
    fNExMax = clus.fNExMax;
    fTOF = clus.fTOF;
    fTracksMatched = clus.fTracksMatched;

    fNCells= clus. fNCells;
    if (clus.fNCells > 0) {
      
      if(clus.fCellsAbsId){
	fCellsAbsId = new UShort_t[clus.fNCells];
	for (Int_t i=0; i<clus.fNCells; i++)
	  fCellsAbsId[i]=clus.fCellsAbsId[i];
      }
      
      if(clus.fCellsAmpFraction){
	fCellsAmpFraction = new Double32_t[clus.fNCells];
	for (Int_t i=0; i<clus.fNCells; i++)
	  fCellsAmpFraction[i]=clus.fCellsAmpFraction[i];
      }
      
    }

  }

  return *this;
}

//_______________________________________________________________________
Bool_t AliAODCaloCluster::HasTrackMatched(TObject *trk) const
{
  // Checks if the given track contributed to this cluster.

  TRefArrayIter iter(&fTracksMatched);
  while (TObject *track = iter.Next()) {
    if (trk == track) return kTRUE;
  }
  return kFALSE;
}

//_______________________________________________________________________
void AliAODCaloCluster::GetMomentum(TLorentzVector& p, Double_t *vertex ) {
  // Returns TLorentzVector with momentum of the cluster. Only valid for clusters 
  // identified as photons or pi0 (overlapped gamma) produced on the vertex
  //Vertex can be recovered with esd pointer doing:  
  //" Double_t vertex[3] ; esd->GetVertex()->GetXYZ(vertex) ; "

  Double32_t energy = E();
  Double32_t pos[3];
  GetPosition(pos);
  
  if(vertex){//calculate direction from vertex
    pos[0]-=vertex[0];
    pos[1]-=vertex[1];
    pos[2]-=vertex[2];
  }
  
  Double_t r = TMath::Sqrt(pos[0]*pos[0]+
			   pos[1]*pos[1]+
			   pos[2]*pos[2]   ) ; 
  
  p.SetPxPyPzE( energy*pos[0]/r,  energy*pos[1]/r,  energy*pos[2]/r,  energy) ; 
  
}


void  AliAODCaloCluster::SetCellsAbsId(UShort_t *array)
{
    //  Set the array of cell absId numbers 
    if (fNCells) {
	fCellsAbsId = new  UShort_t[fNCells];
	for (Int_t i = 0; i < fNCells; i++) fCellsAbsId[i] = array[i];
    }
}

void  AliAODCaloCluster::SetCellsAmplitudeFraction(Double32_t *array)
{
    //  Set the array of cell amplitude fraction
    if (fNCells) {
	fCellsAmpFraction = new  Double32_t[fNCells];
	for (Int_t i = 0; i < fNCells; i++) fCellsAmpFraction[i] = array[i];
    }
}
Commit	Line	Data
fa86343a	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 calorimeter cluster class (for PHOS and EMCAL)
	20	// Author: Markus Oldenburg, CERN
	21	//-------------------------------------------------------------------------
	22
78902954	23	#include <TLorentzVector.h>
fa86343a	24	#include "AliAODCaloCluster.h"
	25
	26	ClassImp(AliAODCaloCluster)
	27
	28	//______________________________________________________________________________
	29	AliAODCaloCluster::AliAODCaloCluster() :
	30	AliAODCluster(),
	31	fDistToBadChannel(-999.),
	32	fDispersion(-1),
	33	fM20(0.),
fa86343a	34	fM02(0.),
fa86343a	35	fEmcCpvDistance(-999.),
78902954	36	fNExMax(0),
78902954	37	fTOF(0.),
fa86343a	38	fTracksMatched(),
e649177a	39	fNCells(0),
	40	fCellsAbsId(),
	41	fCellsAmpFraction()
fa86343a	42	{
	43	// default constructor
	44
	45	}
	46
	47	//______________________________________________________________________________
	48	AliAODCaloCluster::AliAODCaloCluster(Int_t id,
	49	UInt_t nLabel,
	50	Int_t *label,
	51	Double_t energy,
	52	Double_t x[3],
83dd7da3	53	Double_t pid[13],
fa86343a	54	Char_t ttype,
	55	UInt_t selectInfo) :
	56	AliAODCluster(id, nLabel, label, energy, x, pid, ttype, selectInfo),
	57	fDistToBadChannel(-999.),
	58	fDispersion(-1),
	59	fM20(0.),
fa86343a	60	fM02(0.),
fa86343a	61	fEmcCpvDistance(-999.),
fa86343a	62	fNExMax(0),
78902954	63	fTOF(0.),
fa86343a	64	fTracksMatched(),
e649177a	65	fNCells(0),
	66	fCellsAbsId(),
	67	fCellsAmpFraction()
fa86343a	68	{
	69	// constructor
	70
	71	}
	72
	73	//______________________________________________________________________________
	74	AliAODCaloCluster::AliAODCaloCluster(Int_t id,
	75	UInt_t nLabel,
	76	Int_t *label,
	77	Float_t energy,
	78	Float_t x[3],
83dd7da3	79	Float_t pid[13],
fa86343a	80	Char_t ttype,
	81	UInt_t selectInfo) :
	82	AliAODCluster(id, nLabel, label, energy, x, pid, ttype, selectInfo),
	83	fDistToBadChannel(-999.),
	84	fDispersion(-1),
	85	fM20(0.),
fa86343a	86	fM02(0.),
fa86343a	87	fEmcCpvDistance(-999.),
fa86343a	88	fNExMax(0),
78902954	89	fTOF(0.),
fa86343a	90	fTracksMatched(),
e649177a	91	fNCells(0),
	92	fCellsAbsId(),
	93	fCellsAmpFraction()
fa86343a	94	{
	95	// constructor
	96	}
	97
	98
	99	//______________________________________________________________________________
	100	AliAODCaloCluster::~AliAODCaloCluster()
	101	{
	102	// destructor
e649177a	103	if(fCellsAmpFraction) delete[] fCellsAmpFraction; fCellsAmpFraction=0;
e649177a	104	if(fCellsAbsId) delete[] fCellsAbsId; fCellsAbsId = 0;
fa86343a	105	}
	106
	107
	108	//______________________________________________________________________________
	109	AliAODCaloCluster::AliAODCaloCluster(const AliAODCaloCluster& clus) :
	110	AliAODCluster(clus),
	111	fDistToBadChannel(clus.fDistToBadChannel),
	112	fDispersion(clus.fDispersion),
	113	fM20(clus.fM20),
fa86343a	114	fM02(clus.fM02),
fa86343a	115	fEmcCpvDistance(clus.fEmcCpvDistance),
fa86343a	116	fNExMax(clus.fNExMax),
78902954	117	fTOF(clus.fTOF),
fa86343a	118	fTracksMatched(clus.fTracksMatched),
e649177a	119	fNCells(clus.fNCells),
	120	fCellsAbsId(),
	121	fCellsAmpFraction()
fa86343a	122	{
fa86343a	123	// Copy constructor
e649177a	124
	125	if (clus.fNCells > 0) {
	126
	127	if(clus.fCellsAbsId){
	128	fCellsAbsId = new UShort_t[clus.fNCells];
	129	for (Int_t i=0; i<clus.fNCells; i++)
	130	fCellsAbsId[i]=clus.fCellsAbsId[i];
	131	}
	132
	133	if(clus.fCellsAmpFraction){
	134	fCellsAmpFraction = new Double32_t[clus.fNCells];
	135	for (Int_t i=0; i<clus.fNCells; i++)
	136	fCellsAmpFraction[i]=clus.fCellsAmpFraction[i];
	137	}
	138
	139	}
	140
fa86343a	141	}
	142
	143	//______________________________________________________________________________
	144	AliAODCaloCluster& AliAODCaloCluster::operator=(const AliAODCaloCluster& clus)
	145	{
	146	// Assignment operator
	147	if(this!=&clus) {
	148
	149	AliAODCluster::operator=(clus);
	150
	151	fDistToBadChannel = clus.fDistToBadChannel;
	152	fDispersion = clus.fDispersion;
	153	fM20 = clus.fM20;
fa86343a	154	fM02 = clus.fM02;
fa86343a	155	fEmcCpvDistance = clus.fEmcCpvDistance;
fa86343a	156	fNExMax = clus.fNExMax;
78902954	157	fTOF = clus.fTOF;
fa86343a	158	fTracksMatched = clus.fTracksMatched;
e649177a	159
	160	fNCells= clus. fNCells;
	161	if (clus.fNCells > 0) {
	162
	163	if(clus.fCellsAbsId){
	164	fCellsAbsId = new UShort_t[clus.fNCells];
	165	for (Int_t i=0; i<clus.fNCells; i++)
	166	fCellsAbsId[i]=clus.fCellsAbsId[i];
	167	}
	168
	169	if(clus.fCellsAmpFraction){
	170	fCellsAmpFraction = new Double32_t[clus.fNCells];
	171	for (Int_t i=0; i<clus.fNCells; i++)
	172	fCellsAmpFraction[i]=clus.fCellsAmpFraction[i];
	173	}
	174
	175	}
	176
fa86343a	177	}
	178
	179	return *this;
	180	}
	181
	182	//_______________________________________________________________________
	183	Bool_t AliAODCaloCluster::HasTrackMatched(TObject *trk) const
	184	{
	185	// Checks if the given track contributed to this cluster.
	186
	187	TRefArrayIter iter(&fTracksMatched);
	188	while (TObject *track = iter.Next()) {
	189	if (trk == track) return kTRUE;
	190	}
	191	return kFALSE;
	192	}
78902954	193
	194	//_______________________________________________________________________
	195	void AliAODCaloCluster::GetMomentum(TLorentzVector& p, Double_t *vertex ) {
	196	// Returns TLorentzVector with momentum of the cluster. Only valid for clusters
	197	// identified as photons or pi0 (overlapped gamma) produced on the vertex
	198	//Vertex can be recovered with esd pointer doing:
	199	//" Double_t vertex[3] ; esd->GetVertex()->GetXYZ(vertex) ; "
	200
	201	Double32_t energy = E();
	202	Double32_t pos[3];
	203	GetPosition(pos);
	204
	205	if(vertex){//calculate direction from vertex
	206	pos[0]-=vertex[0];
	207	pos[1]-=vertex[1];
	208	pos[2]-=vertex[2];
	209	}
	210
	211	Double_t r = TMath::Sqrt(pos[0]*pos[0]+
	212	pos[1]*pos[1]+
	213	pos[2]*pos[2] ) ;
	214
	215	p.SetPxPyPzE( energypos[0]/r, energypos[1]/r, energy*pos[2]/r, energy) ;
	216
	217	}
1b54b5a3	218
	219
	220	void AliAODCaloCluster::SetCellsAbsId(UShort_t *array)
	221	{
	222	// Set the array of cell absId numbers
	223	if (fNCells) {
	224	fCellsAbsId = new UShort_t[fNCells];
	225	for (Int_t i = 0; i < fNCells; i++) fCellsAbsId[i] = array[i];
	226	}
	227	}
	228
	229	void AliAODCaloCluster::SetCellsAmplitudeFraction(Double32_t *array)
	230	{
	231	// Set the array of cell amplitude fraction
	232	if (fNCells) {
	233	fCellsAmpFraction = new Double32_t[fNCells];
	234	for (Int_t i = 0; i < fNCells; i++) fCellsAmpFraction[i] = array[i];
	235	}
	236	}