[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(0x0),
  fCellsAmpFraction(0x0)
{
  // 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(0x0),
  fCellsAmpFraction(0x0)
{
  // 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(0x0),
  fCellsAmpFraction(0x0)
{
  // 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(0x0),
  fCellsAmpFraction(0x0)
{
  // 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;
    // delete anyway 
    if(fCellsAbsId)delete [] fCellsAbsId;
    if(fCellsAmpFraction)delete [] fCellsAmpFraction;

    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) {
      if(!fCellsAbsId)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) {
      if(!fCellsAmpFraction)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),
341952b8	40	fCellsAbsId(0x0),
341952b8	41	fCellsAmpFraction(0x0)
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),
341952b8	66	fCellsAbsId(0x0),
341952b8	67	fCellsAmpFraction(0x0)
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),
341952b8	92	fCellsAbsId(0x0),
341952b8	93	fCellsAmpFraction(0x0)
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),
341952b8	120	fCellsAbsId(0x0),
341952b8	121	fCellsAmpFraction(0x0)
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
e649177a	160	fNCells= clus. fNCells;
341952b8	161	// delete anyway
	162	if(fCellsAbsId)delete [] fCellsAbsId;
	163	if(fCellsAmpFraction)delete [] fCellsAmpFraction;
	164
e649177a	165	if (clus.fNCells > 0) {
	166
	167	if(clus.fCellsAbsId){
	168	fCellsAbsId = new UShort_t[clus.fNCells];
	169	for (Int_t i=0; i<clus.fNCells; i++)
	170	fCellsAbsId[i]=clus.fCellsAbsId[i];
	171	}
	172
	173	if(clus.fCellsAmpFraction){
	174	fCellsAmpFraction = new Double32_t[clus.fNCells];
	175	for (Int_t i=0; i<clus.fNCells; i++)
	176	fCellsAmpFraction[i]=clus.fCellsAmpFraction[i];
	177	}
	178
	179	}
	180
fa86343a	181	}
	182
	183	return *this;
	184	}
	185
	186	//_______________________________________________________________________
	187	Bool_t AliAODCaloCluster::HasTrackMatched(TObject *trk) const
	188	{
	189	// Checks if the given track contributed to this cluster.
	190
	191	TRefArrayIter iter(&fTracksMatched);
	192	while (TObject *track = iter.Next()) {
	193	if (trk == track) return kTRUE;
	194	}
	195	return kFALSE;
	196	}
78902954	197
	198	//_______________________________________________________________________
	199	void AliAODCaloCluster::GetMomentum(TLorentzVector& p, Double_t *vertex ) {
	200	// Returns TLorentzVector with momentum of the cluster. Only valid for clusters
	201	// identified as photons or pi0 (overlapped gamma) produced on the vertex
	202	//Vertex can be recovered with esd pointer doing:
	203	//" Double_t vertex[3] ; esd->GetVertex()->GetXYZ(vertex) ; "
	204
	205	Double32_t energy = E();
	206	Double32_t pos[3];
	207	GetPosition(pos);
	208
	209	if(vertex){//calculate direction from vertex
	210	pos[0]-=vertex[0];
	211	pos[1]-=vertex[1];
	212	pos[2]-=vertex[2];
	213	}
	214
	215	Double_t r = TMath::Sqrt(pos[0]*pos[0]+
	216	pos[1]*pos[1]+
	217	pos[2]*pos[2] ) ;
	218
	219	p.SetPxPyPzE( energypos[0]/r, energypos[1]/r, energy*pos[2]/r, energy) ;
	220
	221	}
1b54b5a3	222
	223
	224	void AliAODCaloCluster::SetCellsAbsId(UShort_t *array)
	225	{
	226	// Set the array of cell absId numbers
	227	if (fNCells) {
341952b8	228	if(!fCellsAbsId)fCellsAbsId = new UShort_t[fNCells];
341952b8	229	for (Int_t i = 0; i < fNCells; i++) fCellsAbsId[i] = array[i];
1b54b5a3	230	}
	231	}
	232
	233	void AliAODCaloCluster::SetCellsAmplitudeFraction(Double32_t *array)
	234	{
	235	// Set the array of cell amplitude fraction
	236	if (fNCells) {
341952b8	237	if(!fCellsAmpFraction)fCellsAmpFraction = new Double32_t[fNCells];
341952b8	238	for (Int_t i = 0; i < fNCells; i++) fCellsAmpFraction[i] = array[i];
1b54b5a3	239	}
1b54b5a3	240	}