[u/mrichter/AliRoot.git] / PWG4 / CaloCalib / AliAnalysisTaskCaloFilter.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, 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: AliAnalysisTaskCaloFilter.cxx $ */

//////////////////////////////////////////////////////////
// Filter the ESDCaloClusters and ESDCaloCells of EMCAL,
// PHOS or both, creating the corresponing AODCaloClusters
// and AODCaloCells.
// Keep also the AODHeader information and the vertex.
// Needed for calorimeter calibration.
// Copy of AliAnalysisTaskESDfilter.
// Author: Gustavo Conesa Balbastre (INFN - Frascati)
//////////////////////////////////////////////////////////

#include "AliAnalysisTaskCaloFilter.h"
#include "AliESDEvent.h"
#include "AliAODEvent.h"
#include "AliESDCaloCluster.h"
#include "AliESDCaloCells.h"
#include "AliLog.h"

ClassImp(AliAnalysisTaskCaloFilter)
  
////////////////////////////////////////////////////////////////////////

AliAnalysisTaskCaloFilter::AliAnalysisTaskCaloFilter():
  AliAnalysisTaskSE(),
  fCalorimeter("EMCAL PHOS")
{
  // Default constructor
}

//__________________________________________________
AliAnalysisTaskCaloFilter::AliAnalysisTaskCaloFilter(const char* name):
  AliAnalysisTaskSE(name),
  fCalorimeter("EMCAL PHOS")
{
  // Constructor
}

//__________________________________________________
void AliAnalysisTaskCaloFilter::CreateAODFromAOD()
{

  // Copy AOD header, vertex, CaloClusters and CaloCells to output AOD
  
  AliAODEvent* aod = dynamic_cast<AliAODEvent*>(InputEvent());
  
  // set arrays and pointers
  Float_t posF[3];
  Double_t pos[3];
  
  Double_t covVtx[6];
  
  for (Int_t i = 0; i < 6; i++)  covVtx[i] = 0.;
  
  // Update the header
   AliAODHeader* headerin = aod->GetHeader();
  AliAODHeader* header = AODEvent()->GetHeader();
  header->SetRunNumber(headerin->GetRunNumber());
  header->SetBunchCrossNumber(headerin->GetBunchCrossNumber());
  header->SetOrbitNumber(headerin->GetOrbitNumber());
  header->SetPeriodNumber(headerin->GetPeriodNumber());
  header->SetEventType(headerin->GetEventType());
  header->SetMuonMagFieldScale(headerin->GetMuonMagFieldScale()); // FIXME
  header->SetCentrality(headerin->GetCentrality());        // FIXME
  
  
  header->SetTriggerMask(headerin->GetTriggerMask()); 
  header->SetTriggerCluster(headerin->GetTriggerCluster());
  header->SetMagneticField(headerin->GetMagneticField());
  header->SetZDCN1Energy(headerin->GetZDCN1Energy());
  header->SetZDCP1Energy(headerin->GetZDCP1Energy());
  header->SetZDCN2Energy(headerin->GetZDCN2Energy());
  header->SetZDCP2Energy(headerin->GetZDCP2Energy());
  header->SetZDCEMEnergy(headerin->GetZDCEMEnergy(0),headerin->GetZDCEMEnergy(1));
  Float_t diamxy[2]={aod->GetDiamondX(),aod->GetDiamondY()};
  Float_t diamcov[3]; aod->GetDiamondCovXY(diamcov);
  header->SetDiamond(diamxy,diamcov);
  //
  //
  Int_t nVertices = 1 ;/* = prim. vtx*/;
  Int_t nCaloClus = aod->GetNCaloClusters();
  
  AODEvent()->ResetStd(0, nVertices, 0, 0, 0, nCaloClus, 0, 0);
  
  // Access to the AOD container of vertices
  TClonesArray &vertices = *(AODEvent()->GetVertices());
  Int_t jVertices=0;
  
  // Add primary vertex. The primary tracks will be defined
  // after the loops on the composite objects (V0, cascades, kinks)
  const AliAODVertex *vtx = aod->GetPrimaryVertex();
  
  vtx->GetXYZ(pos); // position
  vtx->GetCovMatrix(covVtx); //covariance matrix
  
  AliAODVertex * primary = new(vertices[jVertices++])
    AliAODVertex(pos, covVtx, vtx->GetChi2perNDF(), NULL, -1, AliAODVertex::kPrimary);
  primary->SetName(vtx->GetName());
  primary->SetTitle(vtx->GetTitle());
  
  // Access to the AOD container of clusters
  TClonesArray &caloClusters = *(AODEvent()->GetCaloClusters());
  Int_t jClusters=0;
  
  for (Int_t iClust=0; iClust<nCaloClus; ++iClust) {
    
    AliAODCaloCluster * cluster = aod->GetCaloCluster(iClust);
    
    //Check which calorimeter information we want to keep.
    if     (fCalorimeter.Contains("PHOS")  && !fCalorimeter.Contains("EMCAL") && cluster->IsEMCALCluster()) continue ;
    else if(fCalorimeter.Contains("EMCAL") && !fCalorimeter.Contains("PHOS")  && cluster->IsPHOSCluster())  continue ;
    
    Int_t id       = cluster->GetID();
    Float_t energy = cluster->E();
    cluster->GetPosition(posF);
    Char_t ttype   = cluster->GetType(); 
    
    
    AliAODCaloCluster *caloCluster = new(caloClusters[jClusters++]) 
      AliAODCaloCluster(id,
			0,
			0x0,
			energy,
			posF,
			NULL,
			ttype);
    
    caloCluster->SetCaloCluster(cluster->GetDistToBadChannel(),
				cluster->GetDispersion(),
				cluster->GetM20(), cluster->GetM02(),
				cluster->GetEmcCpvDistance(),  
				cluster->GetNExMax(),cluster->GetTOF()) ;
    
    caloCluster->SetPIDFromESD(cluster->PID());
    caloCluster->SetNCells(cluster->GetNCells());
    caloCluster->SetCellsAbsId(cluster->GetCellsAbsId());
    caloCluster->SetCellsAmplitudeFraction(cluster->GetCellsAmplitudeFraction());
    
  } 
  caloClusters.Expand(jClusters); // resize TObjArray to 'remove' slots for pseudo clusters	 
  // end of loop on calo clusters
  
  // fill EMCAL cell info
  if (fCalorimeter.Contains("EMCAL") && aod->GetEMCALCells()) { // protection against missing ESD information
    AliAODCaloCells &aodinEMcells = *(aod->GetEMCALCells());
    Int_t nEMcell = aodinEMcells.GetNumberOfCells() ;
    
    AliAODCaloCells &aodEMcells = *(AODEvent()->GetEMCALCells());
    aodEMcells.CreateContainer(nEMcell);
    aodEMcells.SetType(AliAODCaloCells::kEMCAL);
    for (Int_t iCell = 0; iCell < nEMcell; iCell++) {      
      aodEMcells.SetCell(iCell,aodinEMcells.GetCellNumber(iCell),aodinEMcells.GetAmplitude(iCell));
    }
    aodEMcells.Sort();
  }
  
  // fill PHOS cell info
  if (fCalorimeter.Contains("PHOS") && aod->GetPHOSCells()) { // protection against missing ESD information
    AliAODCaloCells &aodinPHcells = *(aod->GetPHOSCells());
    Int_t nPHcell = aodinPHcells.GetNumberOfCells() ;
    
    AliAODCaloCells &aodPHcells = *(AODEvent()->GetPHOSCells());
    aodPHcells.CreateContainer(nPHcell);
    aodPHcells.SetType(AliAODCaloCells::kPHOS);
    for (Int_t iCell = 0; iCell < nPHcell; iCell++) {      
      aodPHcells.SetCell(iCell,aodinPHcells.GetCellNumber(iCell),aodinPHcells.GetAmplitude(iCell));
    }
    aodPHcells.Sort();
  }
  
  
  return;
}

//__________________________________________________
void AliAnalysisTaskCaloFilter::CreateAODFromESD()
{

  // Copy ESD header, vertex, CaloClusters and CaloCells to output AOD
  
  AliESDEvent* esd = dynamic_cast<AliESDEvent*>(InputEvent());
  
  // set arrays and pointers
  Float_t posF[3];
  Double_t pos[3];
  
  Double_t covVtx[6];
  
  for (Int_t i = 0; i < 6; i++)  covVtx[i] = 0.;
  
  // Update the header
  
  AliAODHeader* header = AODEvent()->GetHeader();
  header->SetRunNumber(esd->GetRunNumber());
  header->SetBunchCrossNumber(esd->GetBunchCrossNumber());
  header->SetOrbitNumber(esd->GetOrbitNumber());
  header->SetPeriodNumber(esd->GetPeriodNumber());
  header->SetEventType(esd->GetEventType());
  header->SetMuonMagFieldScale(-999.); // FIXME
  header->SetCentrality(-999.);        // FIXME
  
  
  header->SetTriggerMask(esd->GetTriggerMask()); 
  header->SetTriggerCluster(esd->GetTriggerCluster());
  header->SetMagneticField(esd->GetMagneticField());
  header->SetZDCN1Energy(esd->GetZDCN1Energy());
  header->SetZDCP1Energy(esd->GetZDCP1Energy());
  header->SetZDCN2Energy(esd->GetZDCN2Energy());
  header->SetZDCP2Energy(esd->GetZDCP2Energy());
  header->SetZDCEMEnergy(esd->GetZDCEMEnergy(0),esd->GetZDCEMEnergy(1));
  Float_t diamxy[2]={esd->GetDiamondX(),esd->GetDiamondY()};
  Float_t diamcov[3]; esd->GetDiamondCovXY(diamcov);
  header->SetDiamond(diamxy,diamcov);
  //
  //
  Int_t nVertices = 1 ;/* = prim. vtx*/;
  Int_t nCaloClus = esd->GetNumberOfCaloClusters();
  
  AODEvent()->ResetStd(0, nVertices, 0, 0, 0, nCaloClus, 0, 0);
  
  // Access to the AOD container of vertices
  TClonesArray &vertices = *(AODEvent()->GetVertices());
  Int_t jVertices=0;
  
  // Add primary vertex. The primary tracks will be defined
  // after the loops on the composite objects (V0, cascades, kinks)
  const AliESDVertex *vtx = esd->GetPrimaryVertex();
  
  vtx->GetXYZ(pos); // position
  vtx->GetCovMatrix(covVtx); //covariance matrix
  
  AliAODVertex * primary = new(vertices[jVertices++])
    AliAODVertex(pos, covVtx, vtx->GetChi2toNDF(), NULL, -1, AliAODVertex::kPrimary);
  primary->SetName(vtx->GetName());
  primary->SetTitle(vtx->GetTitle());
  
  // Access to the AOD container of clusters
  TClonesArray &caloClusters = *(AODEvent()->GetCaloClusters());
  Int_t jClusters=0;
  
  for (Int_t iClust=0; iClust<nCaloClus; ++iClust) {
    
    AliESDCaloCluster * cluster = esd->GetCaloCluster(iClust);
    
    //Check which calorimeter information we want to keep.
    if     (fCalorimeter.Contains("PHOS")  && !fCalorimeter.Contains("EMCAL") && cluster->IsEMCAL()) continue ;
    else if(fCalorimeter.Contains("EMCAL") && !fCalorimeter.Contains("PHOS")  && cluster->IsPHOS())  continue ;
    
    Int_t id       = cluster->GetID();
    Float_t energy = cluster->E();
    cluster->GetPosition(posF);
    Char_t ttype   = AliAODCluster::kUndef; 
    
    if (cluster->GetClusterType() == AliESDCaloCluster::kPHOSCluster) {
      ttype=AliAODCluster::kPHOSNeutral;
    } 
    else if (cluster->GetClusterType() == AliESDCaloCluster::kEMCALClusterv1) {
      ttype = AliAODCluster::kEMCALClusterv1;
    }
    
    
    AliAODCaloCluster *caloCluster = new(caloClusters[jClusters++]) 
      AliAODCaloCluster(id,
			0,
			0x0,
			energy,
			posF,
			NULL,
			ttype);
    
    caloCluster->SetCaloCluster(cluster->GetDistanceToBadChannel(),
				cluster->GetClusterDisp(),
				cluster->GetM20(), cluster->GetM02(),
				cluster->GetEmcCpvDistance(),  
				cluster->GetNExMax(),cluster->GetTOF()) ;
    
    caloCluster->SetPIDFromESD(cluster->GetPid());
    caloCluster->SetNCells(cluster->GetNCells());
    caloCluster->SetCellsAbsId(cluster->GetCellsAbsId());
    caloCluster->SetCellsAmplitudeFraction(cluster->GetCellsAmplitudeFraction());
    
  } 
  caloClusters.Expand(jClusters); // resize TObjArray to 'remove' slots for pseudo clusters	 
  // end of loop on calo clusters
  
  // fill EMCAL cell info
  if (fCalorimeter.Contains("EMCAL") && esd->GetEMCALCells()) { // protection against missing ESD information
    AliESDCaloCells &esdEMcells = *(esd->GetEMCALCells());
    Int_t nEMcell = esdEMcells.GetNumberOfCells() ;
    
    AliAODCaloCells &aodEMcells = *(AODEvent()->GetEMCALCells());
    aodEMcells.CreateContainer(nEMcell);
    aodEMcells.SetType(AliAODCaloCells::kEMCAL);
    for (Int_t iCell = 0; iCell < nEMcell; iCell++) {      
      aodEMcells.SetCell(iCell,esdEMcells.GetCellNumber(iCell),esdEMcells.GetAmplitude(iCell));
    }
    aodEMcells.Sort();
  }
  
  // fill PHOS cell info
  if (fCalorimeter.Contains("PHOS") && esd->GetPHOSCells()) { // protection against missing ESD information
    AliESDCaloCells &esdPHcells = *(esd->GetPHOSCells());
    Int_t nPHcell = esdPHcells.GetNumberOfCells() ;
    
    AliAODCaloCells &aodPHcells = *(AODEvent()->GetPHOSCells());
    aodPHcells.CreateContainer(nPHcell);
    aodPHcells.SetType(AliAODCaloCells::kPHOS);
    for (Int_t iCell = 0; iCell < nPHcell; iCell++) {      
      aodPHcells.SetCell(iCell,esdPHcells.GetCellNumber(iCell),esdPHcells.GetAmplitude(iCell));
    }
    aodPHcells.Sort();
  }
  
  
  return;
}

//__________________________________________________
void AliAnalysisTaskCaloFilter::Init()
{
  // Initialization
  if (fDebug > 1) AliInfo("Init() \n");
  
}

//__________________________________________________
void AliAnalysisTaskCaloFilter::UserCreateOutputObjects()
{
  // Create the output container
}

//__________________________________________________
void AliAnalysisTaskCaloFilter::UserExec(Option_t */*option*/)
{
  // Execute analysis for current event
  //
  
  Long64_t ientry = Entry();
  if (fDebug > 0)  printf("CaloFilter: Analysing event # %5d\n", (Int_t) ientry);

  const char * dataevent =InputEvent()->GetName();
  if(!strcmp(dataevent,"AliAODEvent"))   CreateAODFromAOD();  
  
  else if(!strcmp(dataevent,"AliESDEvent"))  CreateAODFromESD();
  else {
    AliFatal(Form("Unknown event type %s, ABORT",dataevent));
    
  }

}

//__________________________________________________
void AliAnalysisTaskCaloFilter::Terminate(Option_t */*option*/)
{
  // Terminate analysis
  //
    if (fDebug > 1) printf("AnalysisCaloFilter: Terminate() \n");
}
Commit	Line	Data
7a4cf423	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, 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: AliAnalysisTaskCaloFilter.cxx $ */
	17
	18	//////////////////////////////////////////////////////////
	19	// Filter the ESDCaloClusters and ESDCaloCells of EMCAL,
	20	// PHOS or both, creating the corresponing AODCaloClusters
	21	// and AODCaloCells.
	22	// Keep also the AODHeader information and the vertex.
	23	// Needed for calorimeter calibration.
	24	// Copy of AliAnalysisTaskESDfilter.
	25	// Author: Gustavo Conesa Balbastre (INFN - Frascati)
	26	//////////////////////////////////////////////////////////
	27
	28	#include "AliAnalysisTaskCaloFilter.h"
	29	#include "AliESDEvent.h"
	30	#include "AliAODEvent.h"
	31	#include "AliESDCaloCluster.h"
	32	#include "AliESDCaloCells.h"
	33	#include "AliLog.h"
	34
	35	ClassImp(AliAnalysisTaskCaloFilter)
	36
	37	////////////////////////////////////////////////////////////////////////
	38
	39	AliAnalysisTaskCaloFilter::AliAnalysisTaskCaloFilter():
	40	AliAnalysisTaskSE(),
	41	fCalorimeter("EMCAL PHOS")
	42	{
	43	// Default constructor
	44	}
	45
	46	//__________________________________________________
	47	AliAnalysisTaskCaloFilter::AliAnalysisTaskCaloFilter(const char* name):
	48	AliAnalysisTaskSE(name),
	49	fCalorimeter("EMCAL PHOS")
	50	{
	51	// Constructor
	52	}
	53
	54	//__________________________________________________
	55	void AliAnalysisTaskCaloFilter::CreateAODFromAOD()
	56	{
	57
	58	// Copy AOD header, vertex, CaloClusters and CaloCells to output AOD
	59
	60	AliAODEvent* aod = dynamic_cast<AliAODEvent*>(InputEvent());
	61
	62	// set arrays and pointers
	63	Float_t posF[3];
	64	Double_t pos[3];
65
66	Double_t covVtx[6];
67
68	for (Int_t i = 0; i < 6; i++) covVtx[i] = 0.;
69
70	// Update the header
71	AliAODHeader* headerin = aod->GetHeader();
72	AliAODHeader* header = AODEvent()->GetHeader();
73	header->SetRunNumber(headerin->GetRunNumber());
74	header->SetBunchCrossNumber(headerin->GetBunchCrossNumber());
75	header->SetOrbitNumber(headerin->GetOrbitNumber());
76	header->SetPeriodNumber(headerin->GetPeriodNumber());
77	header->SetEventType(headerin->GetEventType());
78	header->SetMuonMagFieldScale(headerin->GetMuonMagFieldScale()); // FIXME
79	header->SetCentrality(headerin->GetCentrality()); // FIXME
80
81
82	header->SetTriggerMask(headerin->GetTriggerMask());
83	header->SetTriggerCluster(headerin->GetTriggerCluster());
84	header->SetMagneticField(headerin->GetMagneticField());
85	header->SetZDCN1Energy(headerin->GetZDCN1Energy());
86	header->SetZDCP1Energy(headerin->GetZDCP1Energy());
87	header->SetZDCN2Energy(headerin->GetZDCN2Energy());
88	header->SetZDCP2Energy(headerin->GetZDCP2Energy());
89	header->SetZDCEMEnergy(headerin->GetZDCEMEnergy(0),headerin->GetZDCEMEnergy(1));
90	Float_t diamxy[2]={aod->GetDiamondX(),aod->GetDiamondY()};
91	Float_t diamcov[3]; aod->GetDiamondCovXY(diamcov);
92	header->SetDiamond(diamxy,diamcov);
93	//
94	//
95	Int_t nVertices = 1 ;/* = prim. vtx*/;
96	Int_t nCaloClus = aod->GetNCaloClusters();
97
98	AODEvent()->ResetStd(0, nVertices, 0, 0, 0, nCaloClus, 0, 0);
99
100	// Access to the AOD container of vertices
101	TClonesArray &vertices = *(AODEvent()->GetVertices());
102	Int_t jVertices=0;
103
104	// Add primary vertex. The primary tracks will be defined
105	// after the loops on the composite objects (V0, cascades, kinks)
106	const AliAODVertex *vtx = aod->GetPrimaryVertex();
107
108	vtx->GetXYZ(pos); // position
109	vtx->GetCovMatrix(covVtx); //covariance matrix
110
111	AliAODVertex * primary = new(vertices[jVertices++])
112	AliAODVertex(pos, covVtx, vtx->GetChi2perNDF(), NULL, -1, AliAODVertex::kPrimary);
113	primary->SetName(vtx->GetName());
114	primary->SetTitle(vtx->GetTitle());
115
116	// Access to the AOD container of clusters
117	TClonesArray &caloClusters = *(AODEvent()->GetCaloClusters());
118	Int_t jClusters=0;
119
120	for (Int_t iClust=0; iClust<nCaloClus; ++iClust) {
121
122	AliAODCaloCluster * cluster = aod->GetCaloCluster(iClust);
123
124	//Check which calorimeter information we want to keep.
125	if (fCalorimeter.Contains("PHOS") && !fCalorimeter.Contains("EMCAL") && cluster->IsEMCALCluster()) continue ;
126	else if(fCalorimeter.Contains("EMCAL") && !fCalorimeter.Contains("PHOS") && cluster->IsPHOSCluster()) continue ;
127
128	Int_t id = cluster->GetID();
129	Float_t energy = cluster->E();
130	cluster->GetPosition(posF);
131	Char_t ttype = cluster->GetType();
132
133
134	AliAODCaloCluster *caloCluster = new(caloClusters[jClusters++])
135	AliAODCaloCluster(id,
136	0,
137	0x0,
138	energy,
139	posF,
140	NULL,
141	ttype);
142
143	caloCluster->SetCaloCluster(cluster->GetDistToBadChannel(),
144	cluster->GetDispersion(),
145	cluster->GetM20(), cluster->GetM02(),
146	cluster->GetEmcCpvDistance(),
147	cluster->GetNExMax(),cluster->GetTOF()) ;
148
149	caloCluster->SetPIDFromESD(cluster->PID());
150	caloCluster->SetNCells(cluster->GetNCells());
151	caloCluster->SetCellsAbsId(cluster->GetCellsAbsId());
152	caloCluster->SetCellsAmplitudeFraction(cluster->GetCellsAmplitudeFraction());
153
154	}
155	caloClusters.Expand(jClusters); // resize TObjArray to 'remove' slots for pseudo clusters
156	// end of loop on calo clusters
157
158	// fill EMCAL cell info
159	if (fCalorimeter.Contains("EMCAL") && aod->GetEMCALCells()) { // protection against missing ESD information
160	AliAODCaloCells &aodinEMcells = *(aod->GetEMCALCells());
161	Int_t nEMcell = aodinEMcells.GetNumberOfCells() ;
162
163	AliAODCaloCells &aodEMcells = *(AODEvent()->GetEMCALCells());
164	aodEMcells.CreateContainer(nEMcell);
165	aodEMcells.SetType(AliAODCaloCells::kEMCAL);
166	for (Int_t iCell = 0; iCell < nEMcell; iCell++) {
167	aodEMcells.SetCell(iCell,aodinEMcells.GetCellNumber(iCell),aodinEMcells.GetAmplitude(iCell));
168	}
169	aodEMcells.Sort();
170	}
171
172	// fill PHOS cell info
173	if (fCalorimeter.Contains("PHOS") && aod->GetPHOSCells()) { // protection against missing ESD information
174	AliAODCaloCells &aodinPHcells = *(aod->GetPHOSCells());
175	Int_t nPHcell = aodinPHcells.GetNumberOfCells() ;
176
177	AliAODCaloCells &aodPHcells = *(AODEvent()->GetPHOSCells());
178	aodPHcells.CreateContainer(nPHcell);
179	aodPHcells.SetType(AliAODCaloCells::kPHOS);
180	for (Int_t iCell = 0; iCell < nPHcell; iCell++) {
181	aodPHcells.SetCell(iCell,aodinPHcells.GetCellNumber(iCell),aodinPHcells.GetAmplitude(iCell));
182	}
183	aodPHcells.Sort();
184	}
185
186
187	return;
188	}
189
190	//__________________________________________________
191	void AliAnalysisTaskCaloFilter::CreateAODFromESD()
192	{
193
194	// Copy ESD header, vertex, CaloClusters and CaloCells to output AOD
195
196	AliESDEvent* esd = dynamic_cast<AliESDEvent*>(InputEvent());
197
198	// set arrays and pointers
199	Float_t posF[3];
200	Double_t pos[3];
201
202	Double_t covVtx[6];
203
204	for (Int_t i = 0; i < 6; i++) covVtx[i] = 0.;
205
206	// Update the header
207
208	AliAODHeader* header = AODEvent()->GetHeader();
209	header->SetRunNumber(esd->GetRunNumber());
210	header->SetBunchCrossNumber(esd->GetBunchCrossNumber());
211	header->SetOrbitNumber(esd->GetOrbitNumber());
212	header->SetPeriodNumber(esd->GetPeriodNumber());
213	header->SetEventType(esd->GetEventType());
214	header->SetMuonMagFieldScale(-999.); // FIXME
215	header->SetCentrality(-999.); // FIXME
216
217
218	header->SetTriggerMask(esd->GetTriggerMask());
219	header->SetTriggerCluster(esd->GetTriggerCluster());
220	header->SetMagneticField(esd->GetMagneticField());
221	header->SetZDCN1Energy(esd->GetZDCN1Energy());
222	header->SetZDCP1Energy(esd->GetZDCP1Energy());
223	header->SetZDCN2Energy(esd->GetZDCN2Energy());
224	header->SetZDCP2Energy(esd->GetZDCP2Energy());
225	header->SetZDCEMEnergy(esd->GetZDCEMEnergy(0),esd->GetZDCEMEnergy(1));
226	Float_t diamxy[2]={esd->GetDiamondX(),esd->GetDiamondY()};
227	Float_t diamcov[3]; esd->GetDiamondCovXY(diamcov);
228	header->SetDiamond(diamxy,diamcov);
229	//
230	//
231	Int_t nVertices = 1 ;/* = prim. vtx*/;
232	Int_t nCaloClus = esd->GetNumberOfCaloClusters();
233
234	AODEvent()->ResetStd(0, nVertices, 0, 0, 0, nCaloClus, 0, 0);
235
236	// Access to the AOD container of vertices
237	TClonesArray &vertices = *(AODEvent()->GetVertices());
238	Int_t jVertices=0;
239
240	// Add primary vertex. The primary tracks will be defined
241	// after the loops on the composite objects (V0, cascades, kinks)
242	const AliESDVertex *vtx = esd->GetPrimaryVertex();
243
244	vtx->GetXYZ(pos); // position
245	vtx->GetCovMatrix(covVtx); //covariance matrix
246
247	AliAODVertex * primary = new(vertices[jVertices++])
248	AliAODVertex(pos, covVtx, vtx->GetChi2toNDF(), NULL, -1, AliAODVertex::kPrimary);
249	primary->SetName(vtx->GetName());
250	primary->SetTitle(vtx->GetTitle());
251
252	// Access to the AOD container of clusters
253	TClonesArray &caloClusters = *(AODEvent()->GetCaloClusters());
254	Int_t jClusters=0;
255
256	for (Int_t iClust=0; iClust<nCaloClus; ++iClust) {
257
258	AliESDCaloCluster * cluster = esd->GetCaloCluster(iClust);
259
260	//Check which calorimeter information we want to keep.
261	if (fCalorimeter.Contains("PHOS") && !fCalorimeter.Contains("EMCAL") && cluster->IsEMCAL()) continue ;
262	else if(fCalorimeter.Contains("EMCAL") && !fCalorimeter.Contains("PHOS") && cluster->IsPHOS()) continue ;
263
264	Int_t id = cluster->GetID();
265	Float_t energy = cluster->E();
266	cluster->GetPosition(posF);
267	Char_t ttype = AliAODCluster::kUndef;
268
269	if (cluster->GetClusterType() == AliESDCaloCluster::kPHOSCluster) {
270	ttype=AliAODCluster::kPHOSNeutral;
271	}
272	else if (cluster->GetClusterType() == AliESDCaloCluster::kEMCALClusterv1) {
273	ttype = AliAODCluster::kEMCALClusterv1;
274	}
275
276
277	AliAODCaloCluster *caloCluster = new(caloClusters[jClusters++])
278	AliAODCaloCluster(id,
279	0,
280	0x0,
281	energy,
282	posF,
283	NULL,
284	ttype);
285
286	caloCluster->SetCaloCluster(cluster->GetDistanceToBadChannel(),
287	cluster->GetClusterDisp(),
288	cluster->GetM20(), cluster->GetM02(),
289	cluster->GetEmcCpvDistance(),
290	cluster->GetNExMax(),cluster->GetTOF()) ;
291
292	caloCluster->SetPIDFromESD(cluster->GetPid());
293	caloCluster->SetNCells(cluster->GetNCells());
294	caloCluster->SetCellsAbsId(cluster->GetCellsAbsId());
295	caloCluster->SetCellsAmplitudeFraction(cluster->GetCellsAmplitudeFraction());
296
297	}
298	caloClusters.Expand(jClusters); // resize TObjArray to 'remove' slots for pseudo clusters
299	// end of loop on calo clusters
300
301	// fill EMCAL cell info
302	if (fCalorimeter.Contains("EMCAL") && esd->GetEMCALCells()) { // protection against missing ESD information
303	AliESDCaloCells &esdEMcells = *(esd->GetEMCALCells());
304	Int_t nEMcell = esdEMcells.GetNumberOfCells() ;
305
306	AliAODCaloCells &aodEMcells = *(AODEvent()->GetEMCALCells());
307	aodEMcells.CreateContainer(nEMcell);
308	aodEMcells.SetType(AliAODCaloCells::kEMCAL);
309	for (Int_t iCell = 0; iCell < nEMcell; iCell++) {
310	aodEMcells.SetCell(iCell,esdEMcells.GetCellNumber(iCell),esdEMcells.GetAmplitude(iCell));
311	}
312	aodEMcells.Sort();
313	}
314
315	// fill PHOS cell info
316	if (fCalorimeter.Contains("PHOS") && esd->GetPHOSCells()) { // protection against missing ESD information
317	AliESDCaloCells &esdPHcells = *(esd->GetPHOSCells());
318	Int_t nPHcell = esdPHcells.GetNumberOfCells() ;
319
320	AliAODCaloCells &aodPHcells = *(AODEvent()->GetPHOSCells());
321	aodPHcells.CreateContainer(nPHcell);
322	aodPHcells.SetType(AliAODCaloCells::kPHOS);
323	for (Int_t iCell = 0; iCell < nPHcell; iCell++) {
324	aodPHcells.SetCell(iCell,esdPHcells.GetCellNumber(iCell),esdPHcells.GetAmplitude(iCell));
325	}
326	aodPHcells.Sort();
327	}
328
329
330	return;
331	}
332
333	//__________________________________________________
334	void AliAnalysisTaskCaloFilter::Init()
335	{
336	// Initialization
337	if (fDebug > 1) AliInfo("Init() \n");
338
339	}
340
341	//__________________________________________________
342	void AliAnalysisTaskCaloFilter::UserCreateOutputObjects()
343	{
344	// Create the output container
345	}
346
347	//__________________________________________________
348	void AliAnalysisTaskCaloFilter::UserExec(Option_t /option*/)
349	{
350	// Execute analysis for current event
351	//
352
353	Long64_t ientry = Entry();
29a41d05	354	if (fDebug > 0) printf("CaloFilter: Analysing event # %5d\n", (Int_t) ientry);
7a4cf423	355
	356	const char * dataevent =InputEvent()->GetName();
	357	if(!strcmp(dataevent,"AliAODEvent")) CreateAODFromAOD();
	358
	359	else if(!strcmp(dataevent,"AliESDEvent")) CreateAODFromESD();
	360	else {
	361	AliFatal(Form("Unknown event type %s, ABORT",dataevent));
	362
	363	}
	364
	365	}
	366
	367	//__________________________________________________
	368	void AliAnalysisTaskCaloFilter::Terminate(Option_t /option*/)
	369	{
	370	// Terminate analysis
	371	//
	372	if (fDebug > 1) printf("AnalysisCaloFilter: Terminate() \n");
	373	}
	374