Move JETANdev to JETAN (step 1)
authormvl <mvl@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 30 Aug 2013 09:18:25 +0000 (09:18 +0000)
committermvl <mvl@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 30 Aug 2013 09:18:25 +0000 (09:18 +0000)
172 files changed:
JETAN/AliAnalysisTaskDiJets.h
JETAN/AliAnalysisTaskJets.cxx [deleted file]
JETAN/AliAnalysisTaskJets.h [deleted file]
JETAN/AliAnalysisTaskJetsCDF.cxx [deleted file]
JETAN/AliAnalysisTaskJetsCDF.h [deleted file]
JETAN/AliAnalysisTaskJetsFinder.cxx [moved from JETAN/DEV/AliAnalysisTaskJetsFinder.cxx with 100% similarity]
JETAN/AliAnalysisTaskJetsFinder.h [moved from JETAN/DEV/AliAnalysisTaskJetsFinder.h with 100% similarity]
JETAN/AliAnalysisTaskJetsReader.cxx [moved from JETAN/DEV/AliAnalysisTaskJetsReader.cxx with 100% similarity]
JETAN/AliAnalysisTaskJetsReader.h [moved from JETAN/DEV/AliAnalysisTaskJetsReader.h with 100% similarity]
JETAN/AliCdfJetFinder.cxx
JETAN/AliCdfJetFinder.h
JETAN/AliCdfJetHeader.cxx
JETAN/AliCdfJetHeader.h
JETAN/AliDAJetFinder.cxx
JETAN/AliDAJetFinder.h
JETAN/AliDAJetHeader.cxx
JETAN/AliDAJetHeader.h
JETAN/AliFastJetBkg.cxx [moved from JETAN/DEV/AliFastJetBkg.cxx with 100% similarity]
JETAN/AliFastJetBkg.h [moved from JETAN/DEV/AliFastJetBkg.h with 100% similarity]
JETAN/AliFastJetFinder.cxx
JETAN/AliFastJetFinder.h
JETAN/AliFastJetHeader.cxx [deleted file]
JETAN/AliFastJetHeader.h [deleted file]
JETAN/AliFastJetHeaderV1.cxx
JETAN/AliFastJetHeaderV1.h
JETAN/AliFastJetInput.cxx
JETAN/AliFastJetInput.h
JETAN/AliJetAODFillUnitArrayEMCalDigits.cxx [deleted file]
JETAN/AliJetAODFillUnitArrayEMCalDigits.h [deleted file]
JETAN/AliJetAODFillUnitArrayTracks.cxx [deleted file]
JETAN/AliJetAODFillUnitArrayTracks.h [deleted file]
JETAN/AliJetAODReader.cxx [deleted file]
JETAN/AliJetAODReader.h [deleted file]
JETAN/AliJetAODReaderHeader.cxx [deleted file]
JETAN/AliJetAODReaderHeader.h [deleted file]
JETAN/AliJetBkg.cxx
JETAN/AliJetBkg.h
JETAN/AliJetCalTrk.cxx [moved from JETAN/DEV/AliJetCalTrk.cxx with 100% similarity]
JETAN/AliJetCalTrk.h [moved from JETAN/DEV/AliJetCalTrk.h with 100% similarity]
JETAN/AliJetDummyGeo.cxx [deleted file]
JETAN/AliJetDummyGeo.h [deleted file]
JETAN/AliJetDummyShishKebabTrd1Module.cxx [deleted file]
JETAN/AliJetDummyShishKebabTrd1Module.h [deleted file]
JETAN/AliJetESDFillUnitArrayEMCalDigits.cxx [deleted file]
JETAN/AliJetESDFillUnitArrayEMCalDigits.h [deleted file]
JETAN/AliJetESDFillUnitArrayTracks.cxx [deleted file]
JETAN/AliJetESDFillUnitArrayTracks.h [deleted file]
JETAN/AliJetESDReader.cxx [deleted file]
JETAN/AliJetESDReader.h [deleted file]
JETAN/AliJetESDReaderHeader.cxx [deleted file]
JETAN/AliJetESDReaderHeader.h [deleted file]
JETAN/AliJetFillCalTrkEvent.cxx [moved from JETAN/DEV/AliJetFillCalTrkEvent.cxx with 100% similarity]
JETAN/AliJetFillCalTrkEvent.h [moved from JETAN/DEV/AliJetFillCalTrkEvent.h with 100% similarity]
JETAN/AliJetFillCalTrkTrack.cxx [moved from JETAN/DEV/AliJetFillCalTrkTrack.cxx with 100% similarity]
JETAN/AliJetFillCalTrkTrack.h [moved from JETAN/DEV/AliJetFillCalTrkTrack.h with 100% similarity]
JETAN/AliJetFillCalTrkTrackMC.cxx [moved from JETAN/DEV/AliJetFillCalTrkTrackMC.cxx with 100% similarity]
JETAN/AliJetFillCalTrkTrackMC.h [moved from JETAN/DEV/AliJetFillCalTrkTrackMC.h with 100% similarity]
JETAN/AliJetFillUnitArray.cxx [deleted file]
JETAN/AliJetFillUnitArray.h [deleted file]
JETAN/AliJetFinder.cxx
JETAN/AliJetFinder.h [changed mode: 0755->0644]
JETAN/AliJetFinderTypes.cxx [deleted file]
JETAN/AliJetFinderTypes.h [deleted file]
JETAN/AliJetGrid.cxx [deleted file]
JETAN/AliJetGrid.h [deleted file]
JETAN/AliJetHadronCorrection.cxx [deleted file]
JETAN/AliJetHadronCorrection.h [deleted file]
JETAN/AliJetHadronCorrectionv0.cxx [deleted file]
JETAN/AliJetHadronCorrectionv0.h [deleted file]
JETAN/AliJetHadronCorrectionv1.cxx [deleted file]
JETAN/AliJetHadronCorrectionv1.h [deleted file]
JETAN/AliJetHeader.cxx [changed mode: 0755->0644]
JETAN/AliJetHeader.h [changed mode: 0755->0644]
JETAN/AliJetHistos.cxx
JETAN/AliJetHistos.h
JETAN/AliJetKineReader.cxx [deleted file]
JETAN/AliJetKineReader.h [deleted file]
JETAN/AliJetKineReaderHeader.cxx
JETAN/AliJetKineReaderHeader.h
JETAN/AliJetMCReader.cxx [deleted file]
JETAN/AliJetMCReader.h [deleted file]
JETAN/AliJetMCReaderHeader.cxx [deleted file]
JETAN/AliJetMCReaderHeader.h [deleted file]
JETAN/AliJetProductionData.cxx [deleted file]
JETAN/AliJetProductionData.h [deleted file]
JETAN/AliJetReader.cxx [changed mode: 0755->0644]
JETAN/AliJetReader.h [changed mode: 0755->0644]
JETAN/AliJetReaderHeader.cxx [changed mode: 0755->0644]
JETAN/AliJetReaderHeader.h [changed mode: 0755->0644]
JETAN/AliJetSelector.h [deleted file]
JETAN/AliJetUnitArray.cxx [deleted file]
JETAN/AliJetUnitArray.h [deleted file]
JETAN/AliKMeansClustering.cxx [changed mode: 0755->0644]
JETAN/AliKMeansClustering.h [changed mode: 0755->0644]
JETAN/AliPxconeJetFinder.cxx [deleted file]
JETAN/AliPxconeJetFinder.h [deleted file]
JETAN/AliPxconeJetHeader.cxx [deleted file]
JETAN/AliPxconeJetHeader.h [deleted file]
JETAN/AliSISConeJetFinder.cxx
JETAN/AliSISConeJetFinder.h
JETAN/AliSISConeJetHeader.cxx
JETAN/AliSISConeJetHeader.h
JETAN/AliUA1JetFinder.cxx [moved from JETAN/DEV/AliUA1JetFinder.cxx with 100% similarity]
JETAN/AliUA1JetFinder.h [moved from JETAN/DEV/AliUA1JetFinder.h with 100% similarity]
JETAN/AliUA1JetFinderV1.cxx [deleted file]
JETAN/AliUA1JetFinderV1.h [deleted file]
JETAN/AliUA1JetFinderV2.cxx [deleted file]
JETAN/AliUA1JetFinderV2.h [deleted file]
JETAN/AliUA1JetHeader.cxx [deleted file]
JETAN/AliUA1JetHeader.h [deleted file]
JETAN/AliUA1JetHeaderV1.cxx
JETAN/AliUA1JetHeaderV1.h
JETAN/CMakelibFASTJETAN.pkg
JETAN/CMakelibFASTJETANdev.pkg [deleted file]
JETAN/CMakelibJETAN.pkg
JETAN/CMakelibJETANdev.pkg [deleted file]
JETAN/DEV/AliAnalysisTaskDiJets.cxx [deleted file]
JETAN/DEV/AliAnalysisTaskDiJets.h [deleted file]
JETAN/DEV/AliAnalysisTaskFastEmbedding.cxx [deleted file]
JETAN/DEV/AliAnalysisTaskFastEmbedding.h [deleted file]
JETAN/DEV/AliAnalysisTaskJetBackgroundSubtract.cxx [deleted file]
JETAN/DEV/AliAnalysisTaskJetBackgroundSubtract.h [deleted file]
JETAN/DEV/AliAnalysisTaskJetCluster.cxx [deleted file]
JETAN/DEV/AliAnalysisTaskJetCluster.h [deleted file]
JETAN/DEV/AliAnalysisTaskKMeans.cxx [deleted file]
JETAN/DEV/AliAnalysisTaskKMeans.h [deleted file]
JETAN/DEV/AliCdfJetFinder.cxx [deleted file]
JETAN/DEV/AliCdfJetFinder.h [deleted file]
JETAN/DEV/AliCdfJetHeader.cxx [deleted file]
JETAN/DEV/AliCdfJetHeader.h [deleted file]
JETAN/DEV/AliDAJetFinder.cxx [deleted file]
JETAN/DEV/AliDAJetFinder.h [deleted file]
JETAN/DEV/AliDAJetHeader.cxx [deleted file]
JETAN/DEV/AliDAJetHeader.h [deleted file]
JETAN/DEV/AliEventShape.cxx [deleted file]
JETAN/DEV/AliEventShape.h [deleted file]
JETAN/DEV/AliFastJetFinder.cxx [deleted file]
JETAN/DEV/AliFastJetFinder.h [deleted file]
JETAN/DEV/AliFastJetHeaderV1.cxx [deleted file]
JETAN/DEV/AliFastJetHeaderV1.h [deleted file]
JETAN/DEV/AliFastJetInput.cxx [deleted file]
JETAN/DEV/AliFastJetInput.h [deleted file]
JETAN/DEV/AliJetBkg.cxx [deleted file]
JETAN/DEV/AliJetBkg.h [deleted file]
JETAN/DEV/AliJetFinder.cxx [deleted file]
JETAN/DEV/AliJetFinder.h [deleted file]
JETAN/DEV/AliJetHeader.cxx [deleted file]
JETAN/DEV/AliJetHeader.h [deleted file]
JETAN/DEV/AliJetHistos.cxx [deleted file]
JETAN/DEV/AliJetHistos.h [deleted file]
JETAN/DEV/AliJetKineReaderHeader.cxx [deleted file]
JETAN/DEV/AliJetKineReaderHeader.h [deleted file]
JETAN/DEV/AliJetReader.cxx [deleted file]
JETAN/DEV/AliJetReader.h [deleted file]
JETAN/DEV/AliJetReaderHeader.cxx [deleted file]
JETAN/DEV/AliJetReaderHeader.h [deleted file]
JETAN/DEV/AliKMeansClustering.cxx [deleted file]
JETAN/DEV/AliKMeansClustering.h [deleted file]
JETAN/DEV/AliSISConeJetFinder.cxx [deleted file]
JETAN/DEV/AliSISConeJetFinder.h [deleted file]
JETAN/DEV/AliSISConeJetHeader.cxx [deleted file]
JETAN/DEV/AliSISConeJetHeader.h [deleted file]
JETAN/DEV/AliUA1JetHeaderV1.cxx [deleted file]
JETAN/DEV/AliUA1JetHeaderV1.h [deleted file]
JETAN/FASTJETANLinkDef.h
JETAN/FASTJETANdevLinkDef.h [deleted file]
JETAN/PROOF-INF.FASTJETAN/BUILD.sh [deleted file]
JETAN/PROOF-INF.FASTJETAN/SETUP.C [deleted file]
JETAN/PROOF-INF.JETAN/BUILD.sh [deleted file]
JETAN/PROOF-INF.JETAN/SETUP.C [deleted file]
JETAN/macros/demoJETAN.C [moved from JETAN/demoJETAN.C with 100% similarity]
JETAN/macros/testFastJet.C [moved from JETAN/testFastJet.C with 100% similarity]

index cfcf5e3..70e52d4 100644 (file)
@@ -49,7 +49,7 @@ class AliAnalysisTaskDiJets : public AliAnalysisTaskSE
   TH2F         *fH2Pt2vsPt1; // scatter plot with the two jets' Pt
   TH2F         *fH2DifvsSum; // Pt difference vs Pt sum
 
-  ClassDef(AliAnalysisTaskDiJets, 2); // Analysis task for standard dijet analysis
+  ClassDef(AliAnalysisTaskDiJets, 2) // Analysis task for standard dijet analysis
 };
 
 #endif
diff --git a/JETAN/AliAnalysisTaskJets.cxx b/JETAN/AliAnalysisTaskJets.cxx
deleted file mode 100644 (file)
index d92731c..0000000
+++ /dev/null
@@ -1,311 +0,0 @@
-/**************************************************************************
- * 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$ */
-#include <Riostream.h> 
-#include <TROOT.h>
-#include <TSystem.h>
-#include <TInterpreter.h>
-#include <TChain.h>
-#include <TFile.h>
-#include <TList.h>
-#include <TH1.h>
-
-#include "AliAnalysisTaskJets.h"
-#include "AliAnalysisManager.h"
-#include "AliJetFinder.h"
-#include "AliJetHeader.h"
-#include "AliJetReader.h"
-#include "AliJetReaderHeader.h"
-#include "AliJetHistos.h"
-#include "AliESDEvent.h"
-#include "AliESD.h"
-#include "AliAODEvent.h"
-#include "AliAODJetEventBackground.h"
-#include "AliAODHandler.h"
-#include "AliAODExtension.h"
-#include "AliMCEventHandler.h"
-#include "AliESDInputHandler.h"
-#include "AliMCEvent.h"
-#include "AliStack.h"
-
-
-ClassImp(AliAnalysisTaskJets)
-
-////////////////////////////////////////////////////////////////////////
-
-AliAnalysisTaskJets::AliAnalysisTaskJets():
-  AliAnalysisTaskSE(),
-  fConfigFile("ConfigJetAnalysis.C"),
-  fNonStdBranch(""), 
-  fNonStdFile(""),
-  fJetFinder(0x0),
-  fHistos(0x0),
-  fAODExtension(0x0),
-  fListOfHistos(0x0),
-  fChain(0x0),
-  fOpt(0),
-  fReadAODFromOutput(0),
-  fUseAODBackground(kFALSE),
-  fFilterPt(0.)
-{
-  // Default constructor
-}
-
-AliAnalysisTaskJets::AliAnalysisTaskJets(const char* name):
-  AliAnalysisTaskSE(name),
-  fConfigFile("ConfigJetAnalysis.C"),
-  fNonStdBranch(""),
-  fNonStdFile(""),
-  fJetFinder(0x0),
-  fHistos(0x0),
-  fAODExtension(0x0),
-  fListOfHistos(0x0),
-  fChain(0x0),
-  fOpt(0),
-  fReadAODFromOutput(0),
-  fUseAODBackground(kFALSE),
-  fFilterPt(0.)
-{
-  // Default constructor
-  DefineOutput(1, TList::Class());
-}
-
-AliAnalysisTaskJets::AliAnalysisTaskJets(const char* name, TChain* chain):
-  AliAnalysisTaskSE(name),
-  fConfigFile("ConfigJetAnalysis.C"),
-  fNonStdBranch(""),
-  fNonStdFile(""),
-  fJetFinder(0x0),
-  fHistos(0x0),
-  fAODExtension(0x0),
-  fListOfHistos(0x0),
-  fChain(chain),
-  fOpt(0),
-  fReadAODFromOutput(0),
-  fUseAODBackground(kFALSE),
-  fFilterPt(0.)
-{
-  // Default constructor
-  DefineOutput(1, TList::Class());
-}
-
-//----------------------------------------------------------------
-void AliAnalysisTaskJets::UserCreateOutputObjects()
-{
-  // Create the output container
-  //
-  if (fDebug > 1) printf("AnalysisTaskJets::CreateOutPutData() \n");
-
-  AliJetHeader *fH = fJetFinder->GetHeader();
-
-  if(fNonStdBranch.Length()==0)
-    {
-      //  Connec default AOD to jet finder
-      // create a new branch for the background
-
-      if(fUseAODBackground){
-       if(!AODEvent()->FindListObject(AliAODJetEventBackground::StdBranchName())){
-         AliAODJetEventBackground* evBkg = new AliAODJetEventBackground();
-         evBkg->SetName(AliAODJetEventBackground::StdBranchName());
-         AddAODBranch("AliAODJetEventBackground",&evBkg);
-       }
-      }
-      fJetFinder->ConnectAOD(AODEvent());
-    }
-  else
-    {
-      // Create a new branch for jets...
-      // how is this reset? -> cleared in the UserExec....
-      // Can this be handled by the framework?
-      // here we can also have the case that the brnaches are written to a separate file
-
-      TClonesArray *tca = new TClonesArray("AliAODJet", 0);
-      tca->SetName(fNonStdBranch.Data());
-      AddAODBranch("TClonesArray",&tca,fNonStdFile.Data());
-      if(fUseAODBackground){
-       if(!AODEvent() || !AODEvent()->FindListObject(Form("%s_%s",AliAODJetEventBackground::StdBranchName(),fNonStdBranch.Data()))){
-         AliAODJetEventBackground* evBkg = new AliAODJetEventBackground();
-         evBkg->SetName(Form("%s_%s",AliAODJetEventBackground::StdBranchName(),fNonStdBranch.Data()));
-         AddAODBranch("AliAODJetEventBackground",&evBkg,fNonStdFile.Data());
-       }
-      }
-      if(fNonStdFile.Length()!=0){
-       // 
-       // case that we have an AOD extension we need to fetch the jets from the extended output
-       // we identifay the extension aod event by looking for the branchname
-       AliAODHandler *aodH = dynamic_cast<AliAODHandler*>(AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler());
-       fAODExtension = 0;
-       if(aodH){
-         TObjArray* extArray = aodH->GetExtensions();
-         if (extArray) {
-           TIter next(extArray);
-           while ((fAODExtension=(AliAODExtension*)next())){
-             TObject *obj = fAODExtension->GetAOD()->FindListObject(fNonStdBranch.Data());
-             if(fDebug>10){
-               Printf("%s:%d Dumping..",(char*)__FILE__,__LINE__);
-               fAODExtension->GetAOD()->Dump();
-             }
-             if(obj){
-             if(fDebug>1)Printf("AODExtension found for %s",fNonStdBranch.Data());
-             break;
-             }
-             fAODExtension = 0;
-           }
-         }
-       }
-       if(fAODExtension)fJetFinder->ConnectAODNonStd(fAODExtension->GetAOD(), fNonStdBranch.Data()); 
-      }
-      else{
-       if (fDebug > 1) printf("Connecting Non Std Branch AOD %p %s \n",AODEvent(),fNonStdBranch.Data());
-       fJetFinder->ConnectAODNonStd(AODEvent(), fNonStdBranch.Data()); 
-      }
-    }
-
-  // do not add the histograms in the directory
-  // all handled by the list
-  Bool_t oldStatus = TH1::AddDirectoryStatus();
-  TH1::AddDirectory(kFALSE);
-
-
-  // Histograms
-  fListOfHistos = new TList();
-  fListOfHistos->SetOwner();
-  fHistos       = new AliJetHistos();
-  fHistos->AddHistosToList(fListOfHistos);
-  
-  // Add the JetFinderInformation to the Outputlist
-  
-  // Compose a characteristic output name
-  // with the name of the output branch
-  if(fH) {
-    if(fNonStdBranch.Length()==0) {
-      fH->SetName("AliJetHeader_jets");
-    }
-    else {
-      fH->SetName(Form("AliJetHeader_%s",fNonStdBranch.Data()));
-    }
-  }
-
-  TH1::AddDirectory(oldStatus);
-  
-  
-  if(!fAODExtension)OutputTree()->GetUserInfo()->Add(fH);
-  else fAODExtension->GetTree()->GetUserInfo()->Add(fH);
-
-  // post
-  PostData(1, fListOfHistos);
-
-}
-
-//----------------------------------------------------------------
-void AliAnalysisTaskJets::Init()
-{
-  // Initialization
-  if (fDebug > 1) printf("AnalysisTaskJets::Init() \n");
-  
-  // Call configuration file
-  if (fConfigFile.Length()) {
-    gROOT->LoadMacro(fConfigFile);
-    fJetFinder = (AliJetFinder*) gInterpreter->ProcessLine("ConfigJetAnalysis()");
-  }
-  AliJetReaderHeader *header = (AliJetReaderHeader*)fJetFinder->GetReader()->GetReaderHeader();
-  fOpt = header->GetDetector();
-
-// AODB path for Jetan Analysis... if not alread defined, use the standard one
-if ((!(((AliJetReader*) fJetFinder->GetReader())->GetJetanOADBPath()).Length())) {
-((AliJetReader*) fJetFinder->GetReader())->SetJetanOADBPath(AliAnalysisManager::GetOADBPath());
-}
-else Info( "Init"," OADBPath for Jetan was already defined (config file?) as %s",(char*)((fJetFinder->GetReader()->GetJetanOADBPath()).Data()));
-       
-  // Initialise Jet Analysis
-  if(fOpt == 0) fJetFinder->Init();
-  else fJetFinder->InitTask(fChain); // V2
-}
-
-
-//----------------------------------------------------------------
-void AliAnalysisTaskJets::UserExec(Option_t */*option*/)
-{
-  // Execute analysis for current event
-  //
-  // Fill control histos
-  TClonesArray* jarray = 0;
-  AliAODJetEventBackground*  evBkg = 0;
-
-  // only need this once
-  static AliAODHandler *aodH = dynamic_cast<AliAODHandler*>(AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler());
-
-  if(fNonStdBranch.Length()==0) {
-    jarray = AODEvent()->GetJets();
-    if(fUseAODBackground){
-      evBkg = (AliAODJetEventBackground*)(AODEvent()->FindListObject(AliAODJetEventBackground::StdBranchName()));
-      evBkg->Reset();
-    }
-  }
-  else {
-    if(AODEvent())jarray = (TClonesArray*)(AODEvent()->FindListObject(fNonStdBranch.Data()));
-    if(!jarray)jarray = (TClonesArray*)(fAODExtension->GetAOD()->FindListObject(fNonStdBranch.Data()));
-    if(jarray)jarray->Delete();    // this is our responsibility, clear before filling again
-    if(fUseAODBackground){
-      if(AODEvent())evBkg = (AliAODJetEventBackground*)(AODEvent()->FindListObject(Form("%s_%s",AliAODJetEventBackground::StdBranchName(),fNonStdBranch.Data())));
-      if(!evBkg)  evBkg = (AliAODJetEventBackground*)(fAODExtension->GetAOD()->FindListObject(Form("%s_%s",AliAODJetEventBackground::StdBranchName(),fNonStdBranch.Data())));
-      if(evBkg)evBkg->Reset();
-    }
-  }
-
-  if (dynamic_cast<AliAODEvent*>(InputEvent()) !=  0 && !fReadAODFromOutput) {
-// AOD is input event..........................................V                                       
-      fJetFinder->GetReader()->SetInputEvent(InputEvent(), InputEvent(), MCEvent());
-  } else {
-// AOD is read from output ....................................V      
-      fJetFinder->GetReader()->SetInputEvent(InputEvent(), AODEvent(), MCEvent());
-  }
-  
-  
-
-  if(fOpt==0) fJetFinder->ProcessEvent();
-  else fJetFinder->ProcessEvent2();    // V2
-  // Fill control histos
-  if(jarray)fHistos->FillHistos(jarray);
-
-
-  if(jarray&&aodH&&fFilterPt>0){
-    if(jarray->GetEntries()>0){
-      AliAODJet *jet = (AliAODJet*)jarray->At(0);
-      if(jet->Pt()>fFilterPt){
-       //      aodH->EnableFillAODforEvent();
-       aodH->SetFillAOD(kTRUE);
-      }
-    }
-  }
-
-  // Post the data
-  PostData(1, fListOfHistos);
-  return;
-}
-
-
-//*************************************************************
-
-void AliAnalysisTaskJets::Terminate(Option_t */*option*/)
-{
-// Terminate analysis
-//
-    if (fDebug > 1) printf("AnalysisJets: Terminate() \n");
-//    if (fJetFinder) fJetFinder->FinishRun();
-}
-
diff --git a/JETAN/AliAnalysisTaskJets.h b/JETAN/AliAnalysisTaskJets.h
deleted file mode 100644 (file)
index e396cda..0000000
+++ /dev/null
@@ -1,68 +0,0 @@
-//
-// Taks for jet finding in ALICE 
-//
-#ifndef ALIANALYSISTASKJETS_H
-#define ALIANALYSISTASKJETS_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-#include "AliAnalysisTaskSE.h"
-
-
-class AliJetFinder;
-class AliESDEvent;
-class AliAODEvent;
-class AliJetHistos;
-class AliAODExtension;
-class TTree;
-class TChain;
-class TString;
-
-
-
-class AliAnalysisTaskJets : public AliAnalysisTaskSE
-{
- public:
-    AliAnalysisTaskJets();
-    AliAnalysisTaskJets(const char* name);
-    AliAnalysisTaskJets(const char* name, TChain* chain);
-    virtual ~AliAnalysisTaskJets() {;}
-    // Implementation of interface methods
-    virtual void UserCreateOutputObjects();
-    virtual void Init();
-    virtual void LocalInit() {Init();}
-    virtual void UserExec(Option_t *option);
-
-    virtual void SetConfigFile(const char *c) {fConfigFile = c;}
-    virtual void SetJetFinder(AliJetFinder *finder) {fJetFinder = finder;}
-    virtual void SetNonStdBranch(const char *c){fNonStdBranch = c;}
-    virtual const char* GetNonStdBranch(){return fNonStdBranch.Data();}
-    virtual void SetNonStdOutputFile(const char *c){fNonStdFile = c;}
-    virtual const char* GetNonStdOutputFile() {return fNonStdFile.Data();}
-    virtual void SetBookAODBackground(Bool_t b){fUseAODBackground = b;}
-    virtual void Terminate(Option_t *option);
-    virtual void ReadAODFromOutput() {fReadAODFromOutput = kTRUE;}
-    virtual void SetFilterPt(Float_t f){fFilterPt = f;}
-    
- private:
-  AliAnalysisTaskJets(const AliAnalysisTaskJets &det);
-  AliAnalysisTaskJets &operator=(const AliAnalysisTaskJets &det);
-    
- private:
-  TString       fConfigFile;        // the name of the ConfigFile
-  TString       fNonStdBranch;      // the name of the non-std branch name
-  TString       fNonStdFile;        // The optional name of the output file the non-std brnach is written to
-  AliJetFinder* fJetFinder;         //  Pointer to the jet finder 
-  AliJetHistos* fHistos;            //  Histogram manager class
-  AliAODExtension* fAODExtension;   //  AOD extension we in case we write a non-sdt brnach to a separate file and the aod is standard
-  TList*        fListOfHistos;      //  Output list of histograms
-  TChain*       fChain;             //  Chain 
-  Int_t         fOpt;               //  Detector configuration used
-  Bool_t        fReadAODFromOutput; //  Force reading of the AOD from the output
-  Bool_t        fUseAODBackground;  // decide wether we book the backround branch or not 
-  Float_t       fFilterPt;          // use this as a switch for writing the AOD, minium p_T of leading jet   
-  ClassDef(AliAnalysisTaskJets, 7); // Analysis task for standard jet analysis
-};
-#endif
diff --git a/JETAN/AliAnalysisTaskJetsCDF.cxx b/JETAN/AliAnalysisTaskJetsCDF.cxx
deleted file mode 100644 (file)
index 5cca41e..0000000
+++ /dev/null
@@ -1,116 +0,0 @@
-/**************************************************************************
- * 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: AliAnalysisTaskJets.cxx 24457 2008-03-13 10:02:22Z morsch $ */
-
-#include <TROOT.h>
-#include <TSystem.h>
-#include <TInterpreter.h>
-#include <TChain.h>
-#include <TFile.h>
-#include <TList.h>
-
-#include "AliAnalysisManager.h"
-#include "AliCdfJetFinder.h"
-#include "AliESDEvent.h"
-#include "AliESD.h"
-#include "AliAODEvent.h"
-#include "AliAODHandler.h"
-#include "AliMCEventHandler.h"
-#include "AliESDInputHandler.h"
-#include "AliMCEvent.h"
-#include "AliStack.h"
-#include "AliJetReader.h"
-
-#include "AliAnalysisTaskJetsCDF.h"
-
-ClassImp(AliAnalysisTaskJetsCDF)
-
-//______________________________________________________________________________
-AliAnalysisTaskJetsCDF::AliAnalysisTaskJetsCDF():
-    AliAnalysisTaskSE(),
-    fJetFinder(0x0),
-    fListOfHistos(0x0)
-{
-  // Default constructor
-}
-
-//______________________________________________________________________________
-AliAnalysisTaskJetsCDF::AliAnalysisTaskJetsCDF(const char* name):
-    AliAnalysisTaskSE(name),
-    fJetFinder(0x0),
-    fListOfHistos(0x0)
-{
-  // Default constructor
-    DefineOutput(1, TList::Class());
-}
-
-//______________________________________________________________________________
-void AliAnalysisTaskJetsCDF::UserCreateOutputObjects()
-{
-// Create the output container
-//
-    if (fDebug > 1) printf("AnalysisTaskJetsCDF::CreateOutPutData() \n");
-//  Connect default AOD to jet finder
-
-    fJetFinder->ConnectAOD(AODEvent());
-//
-//  Histograms
-    OpenFile(1);
-    fListOfHistos = new TList();
-    if (!fJetFinder) {
-       Error("UserCreateOutputObjects", "No jet finder connected.");
-       return;
-    }
-    fJetFinder->CreateOutputObjects(fListOfHistos);
-}
-
-//______________________________________________________________________________
-void AliAnalysisTaskJetsCDF::LocalInit()
-{
-    // Initialization
-    if (fDebug > 1) printf("AnalysisTaskJets::Init() \n");
-
-    // Call configuration file
-    gROOT->LoadMacro("ConfigJetAnalysisCDF.C");
-    fJetFinder = (AliCdfJetFinder*) gInterpreter->ProcessLine("ConfigJetAnalysis()");
-    // Initialise Jet Analysis
-    fJetFinder->Init();
-    // Write header information to local file
-    fJetFinder->WriteHeaders();
-}
-
-//______________________________________________________________________________
-void AliAnalysisTaskJetsCDF::UserExec(Option_t */*option*/)
-{
-// Execute analysis for current event
-//
-
-    fJetFinder->GetReader()->SetInputEvent(InputEvent(), AODEvent(), MCEvent());
-    fJetFinder->ProcessEvent();
-
-    // Post the data
-    PostData(1, fListOfHistos);
-}
-
-//______________________________________________________________________________
-void AliAnalysisTaskJetsCDF::Terminate(Option_t */*option*/)
-{
-// Terminate analysis
-//
-    if (fDebug > 1) printf("AliAnalysisJetsCDF: Terminate() \n");
-//    if (fJetFinder) fJetFinder->FinishRun();
-}
-
diff --git a/JETAN/AliAnalysisTaskJetsCDF.h b/JETAN/AliAnalysisTaskJetsCDF.h
deleted file mode 100644 (file)
index 57985c9..0000000
+++ /dev/null
@@ -1,40 +0,0 @@
-//
-// CDF jet finding
-//
-#ifndef ALIANALYSISTASKJETSCDF_H
-#define ALIANALYSISTASKJETSCDF_H
-
-/*
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved.
- * See cxx source for full Copyright notice
- *
-*/
-
-#include "AliAnalysisTaskSE.h"
-
-class AliCdfJetFinder;
-class TList;
-
-class AliAnalysisTaskJetsCDF : public AliAnalysisTaskSE
-{
- public:
-    AliAnalysisTaskJetsCDF();
-    AliAnalysisTaskJetsCDF(const char* name);
-    virtual ~AliAnalysisTaskJetsCDF() {;}
-    // Implementation of interface methods
-    virtual void UserCreateOutputObjects();
-    virtual void LocalInit();
-    virtual void UserExec(Option_t *option);
-    virtual void Terminate(Option_t *option);
- private:
-  AliAnalysisTaskJetsCDF(const AliAnalysisTaskJetsCDF &det);
-  AliAnalysisTaskJetsCDF &operator=(const AliAnalysisTaskJetsCDF &det);
-
- private:
-    AliCdfJetFinder* fJetFinder;    //  Pointer to the jet finder
-    TList*           fListOfHistos; //  Output list of histograms
-
-    ClassDef(AliAnalysisTaskJetsCDF, 1); // Analysis task for CDF jet analysis
-};
-
-#endif
index f0a7938..ee21446 100644 (file)
@@ -13,6 +13,8 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
+/* $Id$ */
+
 //---------------------------------------------------------------------
 // Jet Finder based on CDF algortihm
 // Charged jet evolution and the underlying event in proton-antiproton collisions at 1.8 TeV
 // Authors : Adrian.Sevcenco@cern.ch (adriansev@spacescience.ro )
 //           Daniel.Felea@cern.ch    (dfelea@spacescience.ro)
 //           Ciprian.Mihai.Mitu@cern.ch  (mcm@spacescience.ro)
+//           magali.estienne@subatech.in2p3.fr &
+//           alexandre.shabetai@cern.ch (Modification of the input object (reader/finder splitting))
+// ** 2011
+// Modified accordingly to reader/finder splitting and new handling of neutral information
 //---------------------------------------------------------------------
 
-/*
-Changelog
-
-
-
-*/
-
 #include <Riostream.h>
-#include <TROOT.h>
 #include <TMath.h>
 #include <TBits.h>
 #include <TFile.h>
-#include <TCanvas.h>
-#include <TClonesArray.h>
-#include <TLorentzVector.h>
 #include <TH1F.h>
-#include <TH2F.h>
 #include <TProfile.h>
-#include <TArrayF.h>
 #include <TVector2.h>
 
-#include "AliJetReader.h"
-#include "AliJetReaderHeader.h"
 #include "AliAODJet.h"
-#include "AliAODEvent.h"
 #include "AliJetFinder.h"
-
+#include "AliJetCalTrk.h"
 #include "AliCdfJetFinder.h"
 #include "AliCdfJetHeader.h"
 
@@ -57,30 +47,33 @@ ClassImp(AliCdfJetFinder)
 
 //______________________________________________________________________________
 AliCdfJetFinder::AliCdfJetFinder():
-    AliJetFinder(),
-    fHistos(0),
-    fFromAod(0),
-    fAODwrite(0),
-    fAODtracksWrite(0),
-    fAnalyseJets(0),
-    fRefArr (NULL),
-    fNJets(0),
-    fNPart(0),
-    fRadius(0.7),
-    fMinJetParticles(1),
-    fJetPtCut(0.),
-    fVectParticle(NULL),
-    fVectJet(NULL),
-    fPtArray(NULL),
-    fIdxArray(NULL)
-  {  /* Constructor */  }
+  AliJetFinder(),
+  fHistos(0),
+  fAODwrite(0),
+  fAODtracksWrite(0),
+  fAnalyseJets(0),
+  fNJets(0),
+  fNPart(0),
+  fNInC(0),
+  fNInN(0),
+  fRadius(0.7),
+  fMinJetParticles(1),
+  fJetPtCut(0.),
+  fVectParticle(NULL),
+  fVectJet(NULL),
+  fPtArray(NULL),
+  fIdxArray(NULL)
+{  
+  // Default constructor
+}
 
 //______________________________________________________________________________
 AliCdfJetFinder::~AliCdfJetFinder()
-  {
-    Clean();
+{
   // destructor
-  }
+  Clean();
+
+}
 
 //______________________________________________________________________________
 void AliCdfJetFinder::CreateOutputObjects(TList * const histos)
@@ -88,7 +81,7 @@ void AliCdfJetFinder::CreateOutputObjects(TList * const histos)
   // Create the list of histograms. Only the list is owned.
   fHistos = histos;
 
-//  gStyle->SetOptStat(11111111);
+  //  gStyle->SetOptStat(11111111);
 
   TH1F *h1 = new TH1F ("histo1", "Pt distribution of jets", 200, 0,200);  // 1GeV/bin
   h1->SetStats(kTRUE);
@@ -327,106 +320,98 @@ void AliCdfJetFinder::CreateOutputObjects(TList * const histos)
 //______________________________________________________________________________
 void AliCdfJetFinder::FindJets()
 {
-// Jet Algorithm:
-//  * Order all charged particles according to their PT.
-//  * Start with the highest PT particle and include in the "jet" all particles within the "radius" R = 0.7
-//     (considering each particle in the order of decreasing PT and recalculating the centroid of the jet after
-//     each new particle is added to the jet).
-//  * Go to the next highest PT particle (not already included in a jet) and include in the "jet" all particles
-//     (not already included in a jet) within the radius R =0.7.
-//  * Continue until all particles are in a "jet".
+  // Jet Algorithm:
+  //  * Order all charged particles according to their PT.
+  //  * Start with the highest PT particle and include in the "jet" all particles within the "radius" R = 0.7
+  //     (considering each particle in the order of decreasing PT and recalculating the centroid of the jet after
+  //     each new particle is added to the jet).
+  //  * Go to the next highest PT particle (not already included in a jet) and include in the "jet" all particles
+  //     (not already included in a jet) within the radius R =0.7.
+  //  * Continue until all particles are in a "jet".
   if (fDebug) { printf("AliCDJetfinder::FindJets() %d \n", __LINE__ ); }
-AliCdfJetHeader *header = (AliCdfJetHeader*)fHeader;
+  AliCdfJetHeader *header = (AliCdfJetHeader*)fHeader;
 
   if (header)
     {
-    fDebug            = header->GetDebug();
-    fAODwrite         = header->IsAODwrite() ;       // write jets to AOD
-    fAODtracksWrite   = header->IsAODtracksWrite() ; // write jet tracks to AOD
-    fRadius           = header->GetRadius();      // get Radius from jet finder header
-    fMinJetParticles  = header->GetMinPartJet (); // get minimum multiplicity of an jet
-    fJetPtCut         = header->GetJetPtCut ();   // get minimum of jet pt
+      fDebug            = header->GetDebug();
+      fAODwrite         = header->IsAODwrite() ;       // write jets to AOD
+      fAODtracksWrite   = header->IsAODtracksWrite() ; // write jet tracks to AOD
+      fRadius           = header->GetRadius();      // get Radius from jet finder header
+      fMinJetParticles  = header->GetMinPartJet (); // get minimum multiplicity of an jet
+      fJetPtCut         = header->GetJetPtCut ();   // get minimum of jet pt
+      fAnalyseJets      = header->GetAnalyseJets(); // get analyse jet
     }
   else
     { cout << "Header not found" << endl; return; }
 
-if (fAODwrite)
-  {
-  fFromAod = !strcmp(fReader->ClassName(),"AliJetAODReader");
-  if (fFromAod) { fRefArr = fReader->GetReferences(); }
-  }
-
-InitData();
+  InitData();
 
- if (!fNPart) { 
-  if (fDebug) {
-    cout << "entries = 0 ; Event empty !!!" << endl ;
-  }
-  // no need to call clean, InitData does not 
-  // create pointers if npart == 0
-  return; 
- } // if event empty then exit
+  if (!fNPart) { 
+    if (fDebug) {
+      cout << "entries = 0 ; Event empty !!!" << endl ;
+    }
+    // no need to call clean, InitData does not 
+    // create pointers if npart == 0
+    return; 
+  } // if event empty then exit
 
- FindCones();
+  FindCones();
  
- ComputeConesWeight();
+  ComputeConesWeight();
  
- if (fAODwrite) { 
-   if(fDebug)cout << "Writing AOD" << endl ; 
-   WriteJets();
- }
+  if (fAODwrite) { 
+    if(fDebug)cout << "Writing AOD" << endl ; 
+    WriteJets();
+  }
  
- if (fAnalyseJets) AnalizeJets();
+  if (fAnalyseJets) AnalizeJets();
  
- Clean();
+  Clean();
 
 }
 
 //______________________________________________________________________________
 void AliCdfJetFinder::InitData()
 {
-// initialisation of variables and data members
+  // initialisation of variables and data members
 
-  TClonesArray * vectArray = fReader->GetMomentumArray() ;
-  if ( vectArray == 0 ) { cout << "Could not get the momentum array" << endl; return; }
+  if( fHeader->GetDebug() && fCalTrkEvent->GetNCalTrkTracks()  == 0) { cout << "No charged tracks found" << endl; }
 
-  fNPart = vectArray->GetEntries()  ; // n particles in this event;
+  fNPart = fCalTrkEvent->GetNCalTrkTracks() ;
 
-  if ( fNPart == 0 ) { return ; } // if event empty then exit
+  if ( fCalTrkEvent->GetNCalTrkTracks() ) { return; } // if event empty then exit
 
   fVectParticle = new varContainer* [fNPart]; // container for Particles
 
-  fPtArray  = new Double_t [fNPart] ; // momentum array
-  fIdxArray = new Int_t    [fNPart] ; // index array of sorted pts
+  fPtArray  = new Double_t [fCalTrkEvent->GetNCalTrkTracks()] ; 
+  fIdxArray = new Int_t    [fCalTrkEvent->GetNCalTrkTracks()] ; // index array of sorted pts
 
   // initialisation of momentum and index arrays
-  for (  Int_t i = 0 ; i < fNPart ; i++ )
-    {// SORTING STEP :: fPtArray with data from TClonesArray of TLorentzVector
-    TLorentzVector * lv = (TLorentzVector*) vectArray->At(i);
-
-   // INITIALISATION of local arrays for temporary storage
-    varContainer *aParticle = new varContainer;
-    aParticle->pt   = lv->Pt();
-    aParticle->eta  = lv->Eta();
-    aParticle->phi  = TVector2::Phi_mpi_pi ( lv->Phi() ); // normalize to -pi,pi
-    aParticle->njet = -999;
-
-    fVectParticle[i] = aParticle;  // vector of Particles
-
-    // initializing arrays
-    fIdxArray [i] = -999 ;
-     fPtArray [i] = aParticle->pt ;
+  for (  Int_t i = 0 ; i <fCalTrkEvent->GetNCalTrkTracks() ; i++ )
+    {// SORTING STEP :: fPtArray with data from CalTrkTracks
+
+      // INITIALISATION of local arrays for temporary storage
+      varContainer *aParticle = new varContainer;
+      aParticle->pt   = fCalTrkEvent->GetCalTrkTrack(i)->GetPt();
+      aParticle->eta  = fCalTrkEvent->GetCalTrkTrack(i)->GetEta();
+      aParticle->phi  = TVector2::Phi_mpi_pi ( fCalTrkEvent->GetCalTrkTrack(i)->GetPhi() ); // normalize to -pi,pi
+      aParticle->njet = -999;
+
+      fVectParticle[i] = aParticle;  // vector of Particles
+
+      // initializing arrays
+      fIdxArray [i] = -999 ;
+      fPtArray [i] = aParticle->pt ;
     }
 
-  TMath::Sort ( fNPart, fPtArray, fIdxArray ) ; // get a sorted array of indexes with TClonesArray.Size()
+  TMath::Sort ( fNPart, fPtArray, fIdxArray ) ; // get a sorted array of indexes
 
 }
 
-
 //______________________________________________________________________________
 void AliCdfJetFinder::FindCones()
 {
-// parsing of particles in event and estlabish jets (label them with jet index)
+  // parsing of particles in event and estlabish jets (label them with jet index)
 
   Double_t  ptSeed = 0. , etaSeed = 0. , phiSeed = 0. ; // leading particle params
   Double_t pttmp = 0. , etatmp = 0. , phitmp = 0. ; // temporary variables to be used in various calculations
@@ -444,176 +429,177 @@ void AliCdfJetFinder::FindCones()
 
   while ( lkupTable.CountBits() != (UInt_t)fNPart )
     { // loop over particles in event until all flags are set
-    UInt_t firstnonflagged = lkupTable.FirstNullBit() ; // set the index to the first NON flagged bit ; less conditions
+      UInt_t firstnonflagged = lkupTable.FirstNullBit() ; // set the index to the first NON flagged bit ; less conditions
 
-    if(fDebug)cout << "\n\nfirst_non_flagged : " << firstnonflagged << endl;
+      if(fDebug)cout << "\n\nfirst_non_flagged : " << firstnonflagged << endl;
 
-    ++fNJets; // incrementing the jet counter
-    if (fDebug) { printf("JET %d \n", fNJets); }
+      ++fNJets; // incrementing the jet counter
+      if (fDebug) { printf("JET %d \n", fNJets); }
 
-    ptSeed = 0. ; etaSeed = 0. ; phiSeed = 0. ;  // reseting leading particle params
+      ptSeed = 0. ; etaSeed = 0. ; phiSeed = 0. ;  // reseting leading particle params
 
-    for (  UInt_t ipart = firstnonflagged ; ipart < (UInt_t)fNPart ; ipart++ )
-      {// iteration over particles in event
-      // the loop is done over sorted array of pt
-      idxPtSort = fIdxArray[ipart] ;  // index of particle ! fIdxArray is an index list pt sorted
+      for (  UInt_t ipart = firstnonflagged ; ipart < (UInt_t)fNPart ; ipart++ )
+       {// iteration over particles in event
+         // the loop is done over sorted array of pt
+         idxPtSort = fIdxArray[ipart] ;  // index of particle ! fIdxArray is an index list pt sorted
 
-      if ( lkupTable.TestBitNumber(ipart) ) { continue; } // if 4vector is already flagged skip it
+         if ( lkupTable.TestBitNumber(ipart) ) { continue; } // if 4vector is already flagged skip it
 
-      //init computed and used vars
-      pttmp = 0. ; etatmp = 0. ; phitmp = 0. ;
-      deta = 0. ; dphi = 0. ; dcomputed = 0. ; injet = 0 ;
+         //init computed and used vars
+         pttmp = 0. ; etatmp = 0. ; phitmp = 0. ;
+         deta = 0. ; dphi = 0. ; dcomputed = 0. ; injet = 0 ;
 
-      //taking info from fVectParticle ;
-       pttmp = fVectParticle[idxPtSort]->pt ;
-      etatmp = fVectParticle[idxPtSort]->eta ;
-      phitmp = fVectParticle[idxPtSort]->phi ;
+         //taking info from fVectParticle ;
+         pttmp = fVectParticle[idxPtSort]->pt ;
+         etatmp = fVectParticle[idxPtSort]->eta ;
+         phitmp = fVectParticle[idxPtSort]->phi ;
 
-      if ( ipart == firstnonflagged )
-        {// this is first particle in event; leading particle
-        // begin the search around this particle in a fRadius
+         if ( ipart == firstnonflagged )
+           {// this is first particle in event; leading particle
+             // begin the search around this particle in a fRadius
 
-        // CENTRE OF THE JET
-        ptSeed = pttmp ; etaSeed = etatmp ; phiSeed = phitmp ; // seeding the jet with first particle idxPtSort
+             // CENTRE OF THE JET
+             ptSeed = pttmp ; etaSeed = etatmp ; phiSeed = phitmp ; // seeding the jet with first particle idxPtSort
 
-        lkupTable.SetBitNumber ( ipart ) ; // flag the index of particle in lkup_table
-        fVectParticle[idxPtSort]->njet = fNJets ; // associate particle with current jet number
+             lkupTable.SetBitNumber ( ipart ) ; // flag the index of particle in lkup_table
+             fVectParticle[idxPtSort]->njet = fNJets ; // associate particle with current jet number
 
-        if (fDebug) { printf("\nLeading particle :: particle index = %d ;  at sorted index %d ; in jet %d \n", idxPtSort, ipart, fNJets); }
-        if (fDebug) { printf("pt= %g ; eta= %g ; phi = %g \n", pttmp, etatmp, phitmp) ; }
-        if (fDebug) { lkupTable.Print() ;}
+             if (fDebug) { printf("\nLeading particle :: particle index = %d ;  at sorted index %d ; in jet %d \n", idxPtSort, ipart, fNJets); }
+             if (fDebug) { printf("pt= %g ; eta= %g ; phi = %g \n", pttmp, etatmp, phitmp) ; }
+             if (fDebug) { lkupTable.Print() ;}
 
-        continue ; // skip to next particle
-        }
+             continue ; // skip to next particle
+           }
 
-      // condition to be in jet
-      deta = etatmp - etaSeed ;
-      dphi = TVector2::Phi_mpi_pi (phitmp - phiSeed) ; // computing dphi and normalizing to (0,2pi) interval in one step
+         // condition to be in jet
+         deta = etatmp - etaSeed ;
+         dphi = TVector2::Phi_mpi_pi (phitmp - phiSeed) ; // computing dphi and normalizing to (0,2pi) interval in one step
 
-      dcomputed = TMath::Hypot(deta, dphi) ; // Distance(fRadius) to (eta,phi) seed
+         dcomputed = TMath::Hypot(deta, dphi) ; // Distance(fRadius) to (eta,phi) seed
 
-      injet = ( ( fRadius - dcomputed ) >= 0.000000001 ) ? 1 : 0 ; // if r_computed is within jet_r in_jet == 1 else 0
+         injet = ( ( fRadius - dcomputed ) >= 0.000000001 ) ? 1 : 0 ; // if r_computed is within jet_r in_jet == 1 else 0
 
-      if ( injet )
-        { // calculus of jet variables
-        lkupTable.SetBitNumber ( ipart ) ;  // flag the index of particle in lkup_table
-        fVectParticle[idxPtSort]->njet = fNJets ; // setting in particle list the associated jet
+         if ( injet )
+           { // calculus of jet variables
+             lkupTable.SetBitNumber ( ipart ) ;  // flag the index of particle in lkup_table
+             fVectParticle[idxPtSort]->njet = fNJets ; // setting in particle list the associated jet
 
-        if (fDebug) { printf("\njet particle :: particle index = %d ; at sorted index %d ; in jet %d ; found at radius %g ;  \n", idxPtSort, ipart, fNJets, dcomputed); }
-        if (fDebug) { printf("pt= %g ; eta= %g ; phi = %g \n", pttmp, etatmp, phitmp) ; }
-        if (fDebug) { lkupTable.Print() ;}
+             if (fDebug) { printf("\njet particle :: particle index = %d ; at sorted index %d ; in jet %d ; found at radius %g ;  \n", idxPtSort, ipart, fNJets, dcomputed); }
+             if (fDebug) { printf("pt= %g ; eta= %g ; phi = %g \n", pttmp, etatmp, phitmp) ; }
+             if (fDebug) { lkupTable.Print() ;}
 
-        continue ; // skip to next particle
-        }
+             continue ; // skip to next particle
+           }
 
-      }
+       }
       // end of iteration over event; one jet definition of content ; jet parameters to be computed later
     }
-}
 
+}
 
 //______________________________________________________________________________
 void AliCdfJetFinder::ComputeConesWeight()
 {
-// computing of jets Pt, Eta and Phi (centre of weight in (eta,phi) plane)
-// rescan the vector of particles by identify them by asociate jet number for computing of weight centre
+  // computing of jets Pt, Eta and Phi (centre of weight in (eta,phi) plane)
+  // rescan the vector of particles by identify them by asociate jet number for computing of weight centre
 
-// JET CONTAINER
-fVectJet      = new varContainer* [fNJets]; // container for Jets
+  // JET CONTAINER
+  fVectJet      = new varContainer* [fNJets]; // container for Jets
 
-Double_t ptJet, ptJet2 , etaJet , phiJet ; Int_t npartJet ;
-Double_t pttmp = 0. , etatmp = 0. , phitmp = 0. ; // temporary variables to be used in various calculations
-Int_t idxPtSort = -999 ;  // index of array of sorted pt indexes
+  Double_t ptJet, ptJet2 , etaJet , phiJet ; Int_t npartJet ;
+  Double_t pttmp = 0. , etatmp = 0. , phitmp = 0. ; // temporary variables to be used in various calculations
+  Int_t idxPtSort = -999 ;  // index of array of sorted pt indexes
 
-for(  Int_t jet = 0 ; jet < fNJets ; jet++ )
-  {
-  if (fDebug) { printf("\n\n--- Computing weight of Jet %d \n", jet ); }
-  npartJet = 0 ; ptJet = 0. ; etaJet = 0. ; phiJet = 0. ; // reset variables for a new computation
+  for(  Int_t jet = 0 ; jet < fNJets ; jet++ )
+    {
+      if (fDebug) { printf("\n\n--- Computing weight of Jet %d \n", jet ); }
+      npartJet = 0 ; ptJet = 0. ; etaJet = 0. ; phiJet = 0. ; // reset variables for a new computation
 
-  for (  Int_t ipart = 0 ; ipart < fNPart ; ipart++ )
-    {// iteration over particles in event
-    // the loop is done over sorted array of pt
-    idxPtSort = fIdxArray[ipart] ;  // index of particle ! fIdxArray is an index list pt sorted
+      for (  Int_t ipart = 0 ; ipart < fNPart ; ipart++ )
+       {// iteration over particles in event
+         // the loop is done over sorted array of pt
+         idxPtSort = fIdxArray[ipart] ;  // index of particle ! fIdxArray is an index list pt sorted
 
-    if ( fVectParticle[idxPtSort]->njet == jet )
-      {
-      ++npartJet; // incrementing the counter of jet particles
+         if ( fVectParticle[idxPtSort]->njet == jet )
+           {
+             ++npartJet; // incrementing the counter of jet particles
 
-      //taking info from fVectParticle ;
-       pttmp = fVectParticle[idxPtSort]->pt ;
-      etatmp = fVectParticle[idxPtSort]->eta ;
-      phitmp = TVector2::Phi_mpi_pi (fVectParticle[idxPtSort]->phi) ;
+             //taking info from fVectParticle ;
+             pttmp = fVectParticle[idxPtSort]->pt ;
+             etatmp = fVectParticle[idxPtSort]->eta ;
+             phitmp = TVector2::Phi_mpi_pi (fVectParticle[idxPtSort]->phi) ;
 
-//      jet_new_angular_coordinate = jet_old_angular_coordinate * jet_old_pt / jet_new_pt +
-//                                    part[i]_angular_coordinate * part[i]_pt/jet_new_pt
+             //      jet_new_angular_coordinate = jet_old_angular_coordinate * jet_old_pt / jet_new_pt +
+             //                                    part[i]_angular_coordinate * part[i]_pt/jet_new_pt
 
-      ptJet2 = ptJet + pttmp ;
+             ptJet2 = ptJet + pttmp ;
 
-      etaJet = etaJet * ptJet / ptJet2 +  etatmp * pttmp / ptJet2 ;
-      phiJet = phiJet * ptJet / ptJet2 +  phitmp * pttmp / ptJet2 ;
+             etaJet = etaJet * ptJet / ptJet2 +  etatmp * pttmp / ptJet2 ;
+             phiJet = phiJet * ptJet / ptJet2 +  phitmp * pttmp / ptJet2 ;
 
-      ptJet = ptJet2 ;
+             ptJet = ptJet2 ;
 
-      }
-      // add a particle and recalculation of centroid
-    }
-    // end of 1 jet computation
+           }
+         // add a particle and recalculation of centroid
+       }
+      // end of 1 jet computation
 
-    varContainer *aJet = new varContainer;  // Jet container
-    aJet->pt = ptJet; aJet->eta = etaJet; aJet->phi = phiJet; aJet->njet = npartJet; // setting jet vars in container
-    fVectJet[jet] = aJet;   // store the number of the jet(fNJets) and increment afterwards
+      varContainer *aJet = new varContainer;  // Jet container
+      aJet->pt = ptJet; aJet->eta = etaJet; aJet->phi = phiJet; aJet->njet = npartJet; // setting jet vars in container
+      fVectJet[jet] = aJet;   // store the number of the jet(fNJets) and increment afterwards
 
-    if (fDebug) { printf ("=== current jet %d : npartjet= %d ; pt_jet= %g ; eta_jet = %g ; phi_jet = %g \n\n\n",
-                                       jet,     npartJet,      ptJet,      etaJet,       phiJet ) ; }
+      if (fDebug) { printf ("=== current jet %d : npartjet= %d ; pt_jet= %g ; eta_jet = %g ; phi_jet = %g \n\n\n",
+                           jet,     npartJet,      ptJet,      etaJet,       phiJet ) ; }
 
-  }
+    }
   //end loop over jets
 
 }
 
-
 //______________________________________________________________________________
 void AliCdfJetFinder::WriteJets()  
 { 
-// Writing AOD jets and AOD tracks
+  // Writing AOD jets and AOD tracks
 
-for(  Int_t jetnr = 0 ; jetnr < fNJets ; jetnr++ )
-  {
-  Double_t pt = 0., eta = 0., phi = 0., // jet variables
-            px = 0., py = 0., pz = 0., en = 0.; // convert to 4-vector
-  pt  = fVectJet[ jetnr ]->pt   ; // pt  of jet
-  eta = fVectJet[ jetnr ]->eta  ; // eta of jet
-  phi = fVectJet[ jetnr ]->phi  ; // phi of jet
+  for(  Int_t jetnr = 0 ; jetnr < fNJets ; jetnr++ )
+    {
+      Double_t pt = 0., eta = 0., phi = 0., // jet variables
+       px = 0., py = 0., pz = 0., en = 0.; // convert to 4-vector
+      pt  = fVectJet[ jetnr ]->pt   ; // pt  of jet
+      eta = fVectJet[ jetnr ]->eta  ; // eta of jet
+      phi = fVectJet[ jetnr ]->phi  ; // phi of jet
 
-  px = pt * TMath::Cos ( phi ) ;
-  py = pt * TMath::Sin ( phi ) ;
-  pz = pt / TMath::Tan ( 2.0 * TMath::ATan ( TMath::Exp ( -eta ) ) ) ;
-  en = TMath::Sqrt ( px * px + py * py + pz * pz );
+      px = pt * TMath::Cos ( phi ) ;
+      py = pt * TMath::Sin ( phi ) ;
+      pz = pt / TMath::Tan ( 2.0 * TMath::ATan ( TMath::Exp ( -eta ) ) ) ;
+      en = TMath::Sqrt ( px * px + py * py + pz * pz );
 
-  AliAODJet jet (px, py, pz, en);
+      AliAODJet jet (px, py, pz, en);
 
 
-  if (fDebug) jet.Print("");
+      if (fDebug) jet.Print("");
 
-  if (fFromAod && fAODtracksWrite)
-    {
-      for (  Int_t jetTrack = 0; jetTrack < fNPart; jetTrack++ )
-       { if ( fVectParticle[jetTrack]->njet == jetnr ) { jet.AddTrack(fRefArr->At(jetTrack)) ; } }
-    }
-  // tracks REFs written in AOD
-  AddJet(jet);
+      if (fAODtracksWrite)
+       {
+         for (  Int_t jetTrack = 0; jetTrack < fCalTrkEvent->GetNCalTrkTracks(); jetTrack++ )
+           {
+             // The first if condition below has to be checked
+             if ( fVectParticle[jetTrack]->njet == jetnr ) { jet.AddTrack(fCalTrkEvent->GetCalTrkTrack(jetTrack)->GetTrackObject()) ; }
+           }
+       }
+      // tracks REFs written in AOD
+      AddJet(jet);
 
-  }
-//jets vector parsed and written to AOD
+    }
+  //jets vector parsed and written to AOD
 }
 
-
 //______________________________________________________________________________
 void AliCdfJetFinder::AnalizeJets()
 {
-// analyzing of jets and filling of histograms
+  // analyzing of jets and filling of histograms
 
-    const Double_t kPI = TMath::Pi();
+  const Double_t kPI = TMath::Pi();
     
   //persistent pointer to histo20
   TH1F *hR = (TH1F*)fHistos->FindObject("histo20");
@@ -629,17 +615,17 @@ void AliCdfJetFinder::AnalizeJets()
   jetsptidx = new Int_t    [fNJets] ;
   jetspt    = new Double_t [fNJets] ;
 
-//________________________________________________________________________________________
-//  Jet sorting and finding the leading jet that coresponds to cuts in pt and multiplicity
-//________________________________________________________________________________________
+  //________________________________________________________________________________________
+  //  Jet sorting and finding the leading jet that coresponds to cuts in pt and multiplicity
+  //________________________________________________________________________________________
 
   // filing the idx_ptjets array
   if (fDebug) printf("List of unsorted jets:\n");
   for(  Int_t i = 0 ; i < fNJets ; i++ )
     {
-    jetsptidx [i] = 0 ;
-    jetspt    [i] = fVectJet[i]->pt ;
-    if (fDebug) { cout << "   jet found: " << i << " npartjet=" << fVectJet[i]->njet << " ; jets_pt = " << jetspt[i] << endl; }
+      jetsptidx [i] = 0 ;
+      jetspt    [i] = fVectJet[i]->pt ;
+      if (fDebug) { cout << "   jet found: " << i << " npartjet=" << fVectJet[i]->njet << " ; jets_pt = " << jetspt[i] << endl; }
     }
 
   TMath::Sort ( fNJets, jetspt , jetsptidx ) ; // sorting pt of jets
@@ -648,169 +634,168 @@ void AliCdfJetFinder::AnalizeJets()
   // looping over jets searching for __first__ one that coresponds to cuts
   for(  Int_t i = 0 ; i < fNJets ; i++ )
     {
-    if ( ( fVectJet[ jetsptidx[i] ]->njet >= fMinJetParticles ) && ( fVectJet[ jetsptidx[i] ]->pt >= fJetPtCut ) )
-      {
-      leadingjetindex = jetsptidx[i] ;
-      partleadjet = fVectJet[ leadingjetindex ]->njet ; // number of particles in leading jet
-        ptleadjet = fVectJet[ leadingjetindex ]->pt   ; // pt  of leading jet
-       etaleadjet = fVectJet[ leadingjetindex ]->eta  ; // eta of leading jet
-       phileadjet = fVectJet[ leadingjetindex ]->phi  ; // phi of leading jet
-
-      if (fDebug)
-      { printf("Leading jet %d : npart= %d ; pt= %g ; eta = %g ; phi = %g \n", leadingjetindex, partleadjet, ptleadjet, etaleadjet, phileadjet ); }
-
-      break ;
-      }
+      if ( ( fVectJet[ jetsptidx[i] ]->njet >= fMinJetParticles ) && ( fVectJet[ jetsptidx[i] ]->pt >= fJetPtCut ) )
+       {
+         leadingjetindex = jetsptidx[i] ;
+         partleadjet = fVectJet[ leadingjetindex ]->njet ; // number of particles in leading jet
+         ptleadjet = fVectJet[ leadingjetindex ]->pt   ; // pt  of leading jet
+         etaleadjet = fVectJet[ leadingjetindex ]->eta  ; // eta of leading jet
+         phileadjet = fVectJet[ leadingjetindex ]->phi  ; // phi of leading jet
+
+         if (fDebug)
+           { printf("Leading jet %d : npart= %d ; pt= %g ; eta = %g ; phi = %g \n", leadingjetindex, partleadjet, ptleadjet, etaleadjet, phileadjet ); }
+
+         break ;
+       }
     }
-    // end of selection of leading jet
-
+  // end of selection of leading jet
 
 
-//////////////////////////////////////////////////
-////  Computing of values used in histograms
-//////////////////////////////////////////////////
 
-//___________________________________________________________________________
-// pt_sum of all particles in event
-//___________________________________________________________________________
-cout << "Computing sum of pt in event" << endl ;
-Double_t ptsumevent = 0.;
-for (  Int_t i = 0 ; i< fNPart ; i++ ) { ptsumevent += fVectParticle[i]->pt ; }
-printf ("Sum of all Pt in event : pt_sum_event = %g", ptsumevent) ;
+  //////////////////////////////////////////////////
+  ////  Computing of values used in histograms
+  //////////////////////////////////////////////////
 
-//___________________________________________________________________________
-// Filling an array with indexes of leading jet particles
-//___________________________________________________________________________
-Int_t * idxpartLJ = new Int_t [partleadjet] ;
-Int_t counterpartleadjet = 0;
+  //___________________________________________________________________________
+  // pt_sum of all particles in event
+  //___________________________________________________________________________
+  if (fDebug) cout << "Computing sum of pt in event" << endl ;
+  Double_t ptsumevent = 0.;
+  for (  Int_t i = 0 ; i< fNPart ; i++ ) { ptsumevent += fVectParticle[i]->pt ; }
+  if (fDebug) printf ("Sum of all Pt in event : pt_sum_event = %g", ptsumevent) ;
 
-cout << "Filling an array with indexes of leading jet particles" << endl;
+  //___________________________________________________________________________
+  // Filling an array with indexes of leading jet particles
+  //___________________________________________________________________________
+  Int_t * idxpartLJ = new Int_t [partleadjet] ;
+  Int_t counterpartleadjet = 0;
 
-for( Int_t i = 0 ; i < fNPart ; i++ )
-  {
-  if ( fVectParticle[i]->njet == leadingjetindex )
-    {  idxpartLJ[counterpartleadjet++] = i ; }
-  }
-
-if ( (counterpartleadjet-1) > partleadjet ) { cout << " Counter_part_lead_jet > part_leadjet !!!!" << endl;}
+  if (fDebug) cout << "Filling an array with indexes of leading jet particles" << endl;
 
+  for( Int_t i = 0 ; i < fNPart ; i++ )
+    {
+      if ( fVectParticle[i]->njet == leadingjetindex )
+       {  idxpartLJ[counterpartleadjet++] = i ; }
+    }
 
-//___________________________________________________________________________
-// Calculus of part distribution in leading jet
-//___________________________________________________________________________
-Double_t z = 0. ;
-Double_t *zpartljet = new Double_t [ partleadjet ] ; // array of z of particles in leading jet
+  if ( (counterpartleadjet-1) > partleadjet ) { cout << " Counter_part_lead_jet > part_leadjet !!!!" << endl;}
 
-cout << "Entering loop of calculus of part distribution in leading jet" << endl ;
 
-for( Int_t j = 0 ; j < partleadjet ; j++ )
-  {
-  Double_t zj = fVectParticle[idxpartLJ[j]]->pt ;
-  z =  zj / ptleadjet ;
-  zpartljet [j] = z ;
-  cout << "idx_leadjet_part[j] = " << idxpartLJ[j]
-      << " p of particle = " << zj
-      << " pt lead jet = " << ptleadjet
-      << " Z = " << z << endl;
-  }
+  //___________________________________________________________________________
+  // Calculus of part distribution in leading jet
+  //___________________________________________________________________________
+  Double_t z = 0. ;
+  Double_t *zpartljet = new Double_t [ partleadjet ] ; // array of z of particles in leading jet
 
+  if (fDebug) cout << "Entering loop of calculus of part distribution in leading jet" << endl ;
 
-//___________________________________________________________________________
-// array of delta phi's between phi of particles and leading jet phi
-//___________________________________________________________________________
-cout << "array of delta phi's between phi of particles and leading jet phi" << endl;
-Double_t dphipartLJ = 0. ;
-Double_t *dphipartljet = new Double_t [fNPart];
-for(  Int_t part = 0 ; part < fNPart ; part++ )
-  {
-  dphipartLJ = fVectParticle[part]->phi - phileadjet ;
-  dphipartLJ = TVector2::Phi_mpi_pi (dphipartLJ) ; // restrict the delta phi to (-pi,pi) interval
-  dphipartljet [part] = dphipartLJ ;
-  printf("part= %d ; dphi_partLJ = %g  \n", part, dphipartLJ );
-  }
+  for( Int_t j = 0 ; j < partleadjet ; j++ )
+    {
+      Double_t zj = fVectParticle[idxpartLJ[j]]->pt ;
+      z =  zj / ptleadjet ;
+      zpartljet [j] = z ;
+      if (fDebug) cout << "idx_leadjet_part[j] = " << idxpartLJ[j]
+                      << " p of particle = " << zj
+                      << " pt lead jet = " << ptleadjet
+                      << " Z = " << z << endl;
+    }
 
 
-//______________________________________________________________________________
-//  Pt distribution for all particles
-//______________________________________________________________________________
-TH1F * hpt = (TH1F*)fHistos->FindObject("histo11");
-if ( hpt ) { for (  Int_t i = 0 ; i < fNPart ; i++ ) { hpt->Fill( fVectParticle[i]->pt ); } }
+  //___________________________________________________________________________
+  // array of delta phi's between phi of particles and leading jet phi
+  //___________________________________________________________________________
+  if (fDebug) cout << "array of delta phi's between phi of particles and leading jet phi" << endl;
+  Double_t dphipartLJ = 0. ;
+  Double_t *dphipartljet = new Double_t [fNPart];
+  for(  Int_t part = 0 ; part < fNPart ; part++ )
+    {
+      dphipartLJ = fVectParticle[part]->phi - phileadjet ;
+      dphipartLJ = TVector2::Phi_mpi_pi (dphipartLJ) ; // restrict the delta phi to (-pi,pi) interval
+      dphipartljet [part] = dphipartLJ ;
+      if (fDebug) printf("part= %d ; dphi_partLJ = %g  \n", part, dphipartLJ );
+    }
 
-//___________________________________________________________________________
-// Recomputing of radius of particles in leading jet
-//___________________________________________________________________________
-if (fDebug) { printf("   Searching particles with jet index %d\n", leadingjetindex); }
 
-Double_t ddeta = 0. , ddphi = 0. , rpart = 0. ;
+  //______________________________________________________________________________
+  //  Pt distribution for all particles
+  //______________________________________________________________________________
+  TH1F * hpt = (TH1F*)fHistos->FindObject("histo11");
+  if ( hpt ) { for (  Int_t i = 0 ; i < fNPart ; i++ ) { hpt->Fill( fVectParticle[i]->pt ); } }
 
-for( Int_t j = 0 ; j < partleadjet ; j++ )
-  {
-  ddeta = etaleadjet - fVectParticle[idxpartLJ[j]]->eta;
+  //___________________________________________________________________________
+  // Recomputing of radius of particles in leading jet
+  //___________________________________________________________________________
+  if (fDebug) { printf("   Searching particles with jet index %d\n", leadingjetindex); }
 
-  Double_t phitmp = fVectParticle[idxpartLJ[j]]->phi ;
+  Double_t ddeta = 0. , ddphi = 0. , rpart = 0. ;
 
-  ddphi = TVector2::Phi_mpi_pi ( phileadjet - phitmp ) ; // restrict the delta phi to (-pi,pi) interval
+  for( Int_t j = 0 ; j < partleadjet ; j++ )
+    {
+      ddeta = etaleadjet - fVectParticle[idxpartLJ[j]]->eta;
 
-  rpart = TMath::Hypot (ddeta, ddphi) ;
+      Double_t phitmp = fVectParticle[idxpartLJ[j]]->phi ;
 
-  printf ("Particle %d with Re-Computed radius = %f ", idxpartLJ[j], rpart) ;
-  if ( (rpart - fRadius) >= 0.00000001 )
-    { printf ("    bigger than selected radius of %f\n", fRadius ); }
-  else
-    { printf ("\n") ; }
+      ddphi = TVector2::Phi_mpi_pi ( phileadjet - phitmp ) ; // restrict the delta phi to (-pi,pi) interval
 
-  if (hR) hR->Fill(rpart);
+      rpart = TMath::Hypot (ddeta, ddphi) ;
 
-  }
+      if (fDebug) printf ("Particle %d with Re-Computed radius = %f ", idxpartLJ[j], rpart) ;
+      if ( (rpart - fRadius) >= 0.00000001 )
+       { if (fDebug) printf ("    bigger than selected radius of %f\n", fRadius ); }
+      else
+       { if (fDebug) printf ("\n") ; }
 
+      if (hR) hR->Fill(rpart);
 
+    }
 
-//_______________________________________________________________________
-// Computing of radius that contain 80% of Leading Jet ( PT and multiplicity )
-//_______________________________________________________________________
-Double_t corepartleadjet = 0.8 * partleadjet ;
-Double_t coreptleadjet = 0.8 * ptleadjet ;
-Int_t countercorepart = 0 ;
-Double_t countercorept = 0. ;
-Int_t sortedindex = -1 ;
 
-TProfile * hprof24 = (TProfile*)fHistos->FindObject("histo24");
-TProfile * hprof25 = (TProfile*)fHistos->FindObject("histo25");
 
-TProfile * hprof26 = (TProfile*)fHistos->FindObject("histo26");
-TProfile * hprof27 = (TProfile*)fHistos->FindObject("histo27");
-TProfile * hprof28 = (TProfile*)fHistos->FindObject("histo28");
-TProfile * hprof29 = (TProfile*)fHistos->FindObject("histo29");
+  //_______________________________________________________________________
+  // Computing of radius that contain 80% of Leading Jet ( PT and multiplicity )
+  //_______________________________________________________________________
+  Double_t corepartleadjet = 0.8 * partleadjet ;
+  Double_t coreptleadjet = 0.8 * ptleadjet ;
+  Int_t countercorepart = 0 ;
+  Double_t countercorept = 0. ;
+  Int_t sortedindex = -1 ;
 
+  TProfile * hprof24 = (TProfile*)fHistos->FindObject("histo24");
+  TProfile * hprof25 = (TProfile*)fHistos->FindObject("histo25");
+  TProfile * hprof26 = (TProfile*)fHistos->FindObject("histo26");
+  TProfile * hprof27 = (TProfile*)fHistos->FindObject("histo27");
+  TProfile * hprof28 = (TProfile*)fHistos->FindObject("histo28");
+  TProfile * hprof29 = (TProfile*)fHistos->FindObject("histo29");
 
-if ((hprof24) && (hprof25) && (hprof26) && (hprof27) && (hprof28) && (hprof29) )
-{
-for(  Int_t part = 0 ; part < fNPart ; part++ )
-  {
-  Double_t pttmp = 0. ; Double_t etatmp = 0. ; Double_t phitmp = 0. ; // temporary variables
-  Double_t dpart = 0. ;
-  sortedindex = fIdxArray[part] ;
 
-  if ( fVectParticle [ sortedindex ]->njet == leadingjetindex )
+  if ((hprof24) && (hprof25) && (hprof26) && (hprof27) && (hprof28) && (hprof29) )
     {
-     pttmp = fVectParticle[sortedindex]->pt ;
-    etatmp = fVectParticle[sortedindex]->eta ;
-    phitmp = fVectParticle[sortedindex]->phi ;
+      for(  Int_t part = 0 ; part < fNPart ; part++ )
+       {
+         Double_t pttmp = 0. ; Double_t etatmp = 0. ; Double_t phitmp = 0. ; // temporary variables
+         Double_t dpart = 0. ;
+         sortedindex = fIdxArray[part] ;
 
-    ++countercorepart ;
-    countercorept += pttmp ;
+         if ( fVectParticle [ sortedindex ]->njet == leadingjetindex )
+           {
+             pttmp = fVectParticle[sortedindex]->pt ;
+             etatmp = fVectParticle[sortedindex]->eta ;
+             phitmp = fVectParticle[sortedindex]->phi ;
 
-    dpart = TMath::Hypot ( etaleadjet - etatmp, TVector2::Phi_mpi_pi (phileadjet - phitmp) ) ;
+             ++countercorepart ;
+             countercorept += pttmp ;
 
-    if ( countercorepart <=  corepartleadjet ) { hprof24->Fill(ptleadjet, dpart); }
-    if ( countercorept <= coreptleadjet ) { hprof25->Fill(ptleadjet, dpart); }
+             dpart = TMath::Hypot ( etaleadjet - etatmp, TVector2::Phi_mpi_pi (phileadjet - phitmp) ) ;
 
-    if (ptleadjet >  5.) { hprof26->Fill(dpart, countercorepart); hprof28->Fill(dpart, countercorept); }
-    if (ptleadjet > 30.) { hprof27->Fill(dpart, countercorepart); hprof29->Fill(dpart, countercorept); }
+             if ( countercorepart <=  corepartleadjet ) { hprof24->Fill(ptleadjet, dpart); }
+             if ( countercorept <= coreptleadjet ) { hprof25->Fill(ptleadjet, dpart); }
 
+             if (ptleadjet >  5.) { hprof26->Fill(dpart, countercorepart); hprof28->Fill(dpart, countercorept); }
+             if (ptleadjet > 30.) { hprof27->Fill(dpart, countercorepart); hprof29->Fill(dpart, countercorept); }
+
+           }
+       }
     }
-  }
-}
 
   TH1F *hjetpt = (TH1F*)fHistos->FindObject("histo1");
   TH1F *hjeteta = (TH1F*)fHistos->FindObject("histo2");
@@ -819,10 +804,10 @@ for(  Int_t part = 0 ; part < fNPart ; part++ )
 
   for(  Int_t jet = 0 ; jet < fNJets ; jet++ )
     {
-    if (hjetpt)   hjetpt   ->Fill ( fVectJet[jet]->pt   ) ;
-    if (hjeteta)  hjeteta  ->Fill ( fVectJet[jet]->eta  ) ;
-    if (hjetphi)  hjetphi  ->Fill ( fVectJet[jet]->phi  ) ;
-    if (hjetnjet) hjetnjet ->Fill ( fVectJet[jet]->njet ) ;
+      if (hjetpt)   hjetpt   ->Fill ( fVectJet[jet]->pt   ) ;
+      if (hjeteta)  hjeteta  ->Fill ( fVectJet[jet]->eta  ) ;
+      if (hjetphi)  hjetphi  ->Fill ( fVectJet[jet]->phi  ) ;
+      if (hjetnjet) hjetnjet ->Fill ( fVectJet[jet]->njet ) ;
     }
 
   TH1F *hjets = (TH1F*)fHistos->FindObject("histo5");
@@ -835,16 +820,16 @@ for(  Int_t part = 0 ; part < fNPart ; part++ )
   if (hprof) hprof->Fill(ptleadjet,partleadjet);
 
   TH1F *hMD = (TH1F*)fHistos->FindObject("histo8");
-   for(  Int_t k = 0  ; k < partleadjet ; k++)
-     { hMD->Fill( zpartljet[k] ); }
+  for(  Int_t k = 0  ; k < partleadjet ; k++)
+    { hMD->Fill( zpartljet[k] ); }
 
   TProfile * hphi = (TProfile*)fHistos->FindObject("histo9");
-    for(  Int_t k = 0  ; k < partleadjet ; k++)
-        { hphi->Fill( TMath::RadToDeg() * dphipartljet [k] , fNPart ) ; }
+  for(  Int_t k = 0  ; k < partleadjet ; k++)
+    { hphi->Fill( TMath::RadToDeg() * dphipartljet [k] , fNPart ) ; }
 
   TProfile * htpd = (TProfile*)fHistos->FindObject("histo10");
-    for(  Int_t k = 0  ; k < fNPart ; k++)
-        { htpd->Fill( TMath::RadToDeg() * dphipartljet [k] , ptsumevent ) ; }
+  for(  Int_t k = 0  ; k < fNPart ; k++)
+    { htpd->Fill( TMath::RadToDeg() * dphipartljet [k] , ptsumevent ) ; }
 
 
   TProfile * hprof1 = (TProfile*)fHistos->FindObject("histo21");
@@ -865,42 +850,42 @@ for(  Int_t part = 0 ; part < fNPart ; part++ )
 
   if ( (hprof1toward) && (hprof1transverse) && (hprof1away) && (hprof2toward) && (hprof2transverse) && (hprof2away) )
     {
-    for( Int_t part = 0  ; part < fNPart ; part++)
-      {
-      Double_t ptpart = fVectParticle[part]->pt ; // pt of particle
-      if ( ( dphipartljet[part] >=0.) && ( dphipartljet[part] < kPI/3. ) )
-        {
-        hprof1toward->Fill( ptleadjet, fNPart );
-        hprof2toward->Fill( ptleadjet, ptsumevent);
-        hpttoward->Fill( ptpart );
-        }
-      else
-      if ( ( dphipartljet[part] >= (kPI/3.)) && ( dphipartljet[part] < (2.*kPI/3.)) )
-        {
-        hprof1transverse->Fill( ptleadjet, fNPart );
-        hprof2transverse->Fill( ptleadjet, ptsumevent);
-        hpttransverse->Fill( ptpart );
-        }
-      else
-      if ( ( dphipartljet[part] >= ( 2.*kPI/3.)) && ( dphipartljet[part] < kPI ) )
-        {
-        hprof1away->Fill( ptleadjet, fNPart );
-        hprof2away->Fill( ptleadjet, ptsumevent);
-        hptaway->Fill( ptpart );
-        }
-      }
+      for( Int_t part = 0  ; part < fNPart ; part++)
+       {
+         Double_t ptpart = fVectParticle[part]->pt ; // pt of particle
+         if ( ( dphipartljet[part] >=0.) && ( dphipartljet[part] < kPI/3. ) )
+           {
+             hprof1toward->Fill( ptleadjet, fNPart );
+             hprof2toward->Fill( ptleadjet, ptsumevent);
+             hpttoward->Fill( ptpart );
+           }
+         else
+           if ( ( dphipartljet[part] >= (kPI/3.)) && ( dphipartljet[part] < (2.*kPI/3.)) )
+             {
+               hprof1transverse->Fill( ptleadjet, fNPart );
+               hprof2transverse->Fill( ptleadjet, ptsumevent);
+               hpttransverse->Fill( ptpart );
+             }
+           else
+             if ( ( dphipartljet[part] >= ( 2.*kPI/3.)) && ( dphipartljet[part] < kPI ) )
+               {
+                 hprof1away->Fill( ptleadjet, fNPart );
+                 hprof2away->Fill( ptleadjet, ptsumevent);
+                 hptaway->Fill( ptpart );
+               }
+       }
     }
 
   delete [] dphipartljet;
   delete [] zpartljet;
   delete [] idxpartLJ;
-}
 
+}
 
 //______________________________________________________________________________
 void AliCdfJetFinder::Clean()
 {
-// CLEANING SECTION
+  // CLEANING SECTION
   for (  Int_t i = 0 ; i < fNPart ; i++ ){
     delete fVectParticle[i];
     fVectParticle[i] = 0;
@@ -917,11 +902,6 @@ void AliCdfJetFinder::Clean()
   delete [] fIdxArray;fIdxArray = 0;
 
   Reset();
-}
 
-//______________________________________________________________________________
-void AliCdfJetFinder::FinishRun()
-{
-// do i need this?
 }
 
index 9f05e53..8407aad 100644 (file)
@@ -7,6 +7,8 @@
  *
 */
 
+/* $Id$ */
+
 //  Definition of constants, structures and functions for jet finder
 
 #include "AliJetFinder.h"
@@ -16,64 +18,58 @@ using namespace std ;
 
 // structure of jet and particles container
 struct varContainer
-  {
-  Double_t  pt;  // pt of particle/jet
+{
+  Double_t pt;   // pt of particle/jet
   Double_t eta;  // eta of particle/jet
   Double_t phi;  // phi of particle/jet
   Int_t    njet; // njet is multiplicity of jet or if particles are stored , njet is index number of jet 
-  } ;
+};
 
 class AliCdfJetHeader;
 
 class AliCdfJetFinder : public AliJetFinder
-  {
-  public:
-
-    AliCdfJetFinder();
-    virtual ~AliCdfJetFinder();
-
-    void           CreateOutputObjects(TList * const histos);
-    void           FindJets();
-    void           InitData();
-    void           FindCones();
-    void           ComputeConesWeight();
-    void           WriteJets() ;
-    void           AnalizeJets();
-    void           Clean();
-    
-    virtual void   FinishRun();
-
-    void           SetAnalyseJets(Bool_t flag = kTRUE) {fAnalyseJets = flag;}
+{
+ public:
+  AliCdfJetFinder();
+  virtual        ~AliCdfJetFinder();
+
+  void           CreateOutputObjects(TList * const histos);
+  void           FindJets();
+  void           InitData();
+  void           FindCones();
+  void           ComputeConesWeight();
+  void           WriteJets() ;
+  void           AnalizeJets();
+  void           Clean();
     
-  protected:
-    AliCdfJetFinder ( const AliCdfJetFinder& jf );
-    AliCdfJetFinder& operator = ( const AliCdfJetFinder& jf );
+ protected:
+  AliCdfJetFinder ( const AliCdfJetFinder& jf );
+  AliCdfJetFinder& operator = ( const AliCdfJetFinder& jf );
 
-    TList         *fHistos;    // List of histograms
+  TList*         fHistos;          //  List of histograms
 
-    Bool_t fFromAod ;          // is the data taken from AOD (or ESD filter) 
-    Bool_t fAODwrite ;         // write jets to AOD
-    Bool_t fAODtracksWrite ;   // write jet tracks to AOD
-    Bool_t fAnalyseJets;       // analyse jets
+  Bool_t         fAODwrite ;       //  write jets to AOD
+  Bool_t         fAODtracksWrite;  //  write jet tracks to AOD
+  Bool_t         fAnalyseJets;     //  analyse jets
        
-    TRefArray *fRefArr ;       //! pointer to references array of tracks from AOD
-
-    Int_t         fNJets;     //! counter of number of jets
-    Int_t         fNPart;     //! number of particles in event
+  Int_t          fNJets;           //! counter of number of jets
+  Int_t          fNPart;           //! number of particles in event
+  Int_t          fNInC;            //! number of charged particles in event
+  Int_t          fNInN;            //! number of neutral cells in event
 
-    Double_t      fRadius ;   // radius of jet 
+  Double_t       fRadius;          // radius of jet 
 
-    Int_t fMinJetParticles;   // leading jet must contain AT LEAST fMinJetParticles
-    Double_t fJetPtCut;       // leading jet must have AT LEAST fJetPtCut
+  Int_t          fMinJetParticles; //  leading jet must contain AT LEAST fMinJetParticles
+  Double_t       fJetPtCut;        //  leading jet must have AT LEAST fJetPtCut
 
-    varContainer **fVectParticle; //! container for Particles
-    varContainer **fVectJet;      //! container for Jets
+  varContainer** fVectParticle;    //! container for Particles
+  varContainer** fVectJet;         //! container for Jets
 
-    Double_t *fPtArray;  //! momentum array
-    Int_t    *fIdxArray;  //! index array of sorted pts
+  Double_t*      fPtArray;         //! momentum array
+  Int_t*         fIdxArray;        //! index array of sorted pts
 
+  ClassDef(AliCdfJetFinder,3)      //  CDF jet finder
 
-    ClassDef(AliCdfJetFinder,2)
-   };
+};
 #endif
 
index 6efd5e7..0f0cb32 100644 (file)
 
 
 /*
-Changelog
+  Changelog
 
 
 
 */
 
 #include "AliCdfJetHeader.h"
+
 ClassImp ( AliCdfJetHeader )
 
 ////////////////////////////////////////////////////////////////////////
 
-AliCdfJetHeader::AliCdfJetHeader() :
-    fRadius (0.7),
-    fMinPartJet (1),
-    fJetPtCut (0.),
-    fAODwrite (false),
-    fAODtracksWrite (false)
-  {
+AliCdfJetHeader::AliCdfJetHeader():
+  fMinPartJet(1),
+  fJetPtCut(0.),
+  fAODwrite(kFALSE),
+  fAODtracksWrite(kFALSE),
+  fkAnalyseJets(kFALSE)
+{
   // Constructor
-  }
-
-////////////////////////////////////////////////////////////////////////
-
-// void AliCdfJetHeader::PrintParameters() const
-//   {
-//   // prints out parameters of jet algorithm
-//
-//   cout << " CDF simplified jet algorithm " << endl;
-//   cout << " * Jet parameters: " << endl;
-//   cout << " Cone size: " << fRadius << endl;
-//
-//
-//   }
+}
index 7599609..4356fe8 100644 (file)
 #include "AliJetHeader.h"
 
 class AliCdfJetHeader : public AliJetHeader
-  {
-  public:
-
+{
+ public:
   AliCdfJetHeader();
   virtual ~AliCdfJetHeader() { }
 
   // Getters
-  Double_t GetRadius   () const { return fRadius; }
-  Double_t GetJetPtCut () const { return fJetPtCut ; }
-  Int_t GetMinPartJet  () const { return fMinPartJet ; }
+  Double_t GetJetPtCut() const      { return fJetPtCut; }
+  Int_t    GetMinPartJet() const    { return fMinPartJet; }
+  Bool_t   GetAnalyseJets() const   { return fkAnalyseJets; }
 
   // Setters
-  void SetRadius         ( Double_t radius )          { fRadius = radius; }
-  void SetJetPtCut       ( Double_t jetptcut )        { fJetPtCut = jetptcut; }
-  void SetAODwrite       ( Bool_t aodwrite )          { fAODwrite = aodwrite ; }
-  void SetAODtracksWrite ( Bool_t aodtrackswrite )    { fAODtracksWrite = aodtrackswrite ; }
-  void SetMinPartJet     ( Int_t npart )              { fMinPartJet = npart ; }
-
-//  void SetCDFJetHeader   () { fCDFheader = (AliCdfJetHeader*)fHeader; }
-
-  Bool_t IsAODwrite() const { return fAODwrite ; }
-  Bool_t IsAODtracksWrite() const { return fAODtracksWrite ; }
-
-//     void PrintParameters() const ;
-
-  protected:
+  void     SetJetPtCut(Double_t jetptcut)          { fJetPtCut = jetptcut; }
+  void     SetAODwrite(Bool_t aodwrite)            { fAODwrite = aodwrite; }
+  void     SetAODtracksWrite(Bool_t aodtrackswrite){ fAODtracksWrite = aodtrackswrite; }
+  void     SetMinPartJet(Int_t npart)              { fMinPartJet = npart; }
+  void     SetAnalyseJets(Bool_t flag = kTRUE)     { fkAnalyseJets = flag; }
 
-  AliCdfJetHeader(const AliCdfJetHeader &jh);
-  AliCdfJetHeader& operator=(const AliCdfJetHeader &jh);
+  Bool_t   IsAODwrite() const       { return fAODwrite; }
+  Bool_t   IsAODtracksWrite() const { return fAODtracksWrite; }
 
-  // parameters of algorithm
-  Double_t fRadius ;      //  Cone radius
-  Int_t  fMinPartJet ;       // minimum number of particles in jet
+ protected:
+  // Parameters of algorithm
+  Int_t    fMinPartJet;           // minimum number of particles in jet
+  Double_t fJetPtCut;             // pt cut of jets
 
-  // JET Pt cut
-  Double_t fJetPtCut ;  // pt cut of jets
+  Bool_t   fAODwrite;             // flag for writing to AOD
+  Bool_t   fAODtracksWrite;       // flag for writing tracks to AOD
 
-  Bool_t fAODwrite ;         // flag for writing to AOD
-  Bool_t fAODtracksWrite ;   // flag for writing tracks to AOD
+  Bool_t   fkAnalyseJets;         // analyse jets 
 
-//  AliCdfJetHeader* fCDFheader ; // local pointer to CDF Jet Header
+  ClassDef ( AliCdfJetHeader, 2 ) // CDF jet header class
 
-  ClassDef ( AliCdfJetHeader, 1 )
+};
 
-  };
 #endif
index 16685f2..3bd12ee 100644 (file)
 //  * provided "as is" without express or implied warranty.                  *
 //  **************************************************************************
 
+/* $Id$ */
+
 //-----------------------------------------------------------------------------------
 // Jet finder based on Deterministic Annealing
 // For further informations about the DA working features see:
 // Phys.Lett. B601 (2004) 56-63 (http://arxiv.org/abs/hep-ph/0407214)
 // Author: Davide Perrino (davide.perrino@ba.infn.it, davide.perrino@cern.ch)
+//         alexandre.shabetai@cern.ch (Modification of the input object (reader/finder splitting)) 
+// ** 2011
+// Modified accordingly to reader/finder splitting and new handling of neutral information   
 //-----------------------------------------------------------------------------------
 
 #include <TMath.h>
 #include <TRandom2.h>
-#include <TClonesArray.h>
-#include "AliJetReaderHeader.h"
-#include "AliJetReader.h"
+
+#include "AliAODJet.h"
 #include "AliDAJetHeader.h"
 #include "AliDAJetFinder.h"
 
 ClassImp(AliDAJetFinder)
 
+///////////////////////////////////////////////////////////////////////
 
-//-----------------------------------------------------------------------------------
 AliDAJetFinder::AliDAJetFinder():
-       AliJetFinder(),
-       fAlpha(1.01),
-       fDelta(1e-8),
-       fAvDist(1e-6),
-       fEps(1e-4),
-       fEpsMax(1e-2),
-       fNloopMax(100),
-       fBeta(0.1),
-       fNclustMax(0),
-       fNin(0),
-       fNeff(0)
+  AliJetFinder(),
+  fAlpha(1.01),
+  fDelta(1e-8),
+  fAvDist(1e-6),
+  fEps(1e-4),
+  fEpsMax(1e-2),
+  fNloopMax(100),
+  fBeta(0.1),
+  fNclustMax(0),
+  fNin(0),
+  fNeff(0)
 {
-       // Constructor
+  // Constructor
 }
 
 //-----------------------------------------------------------------------------------
 AliDAJetFinder::~AliDAJetFinder()
 {
-       // Destructor
+  // Destructor
 }
 
 //-----------------------------------------------------------------------------------
 void AliDAJetFinder::FindJets()  
 {
-// Find the jets in current event
-// 
-       Float_t betaStop=100.;
-       fDebug = fHeader->GetDebug();
-
-       Double_t dEtSum=0;
-       Double_t *xData[2];
-       TVectorD *vPx = new TVectorD();
-       TVectorD *vPy = new TVectorD();
-       TMatrixD *mPyx= new TMatrixD();
-       TMatrixD *mY  = new TMatrixD();
-       InitDetAnn(dEtSum,xData,vPx,vPy,mPyx,mY);
-       if (fNin < fNclustMax){
-         delete [] xData[0], delete [] xData[1];
-         delete vPx;
-         delete vPy;
-         delete mPyx;
-         delete mY;
-         return;
-       }
-       Int_t nc=1, nk;
-       DoubleClusters(nc,nk,vPy,mY);
-       do{                                     //loop over beta
-               fBeta*=fAlpha;
-               Annealing(nk,xData,vPx,vPy,mPyx,mY);
-               NumCl(nc,nk,vPy,mPyx,mY);
-       }while((fBeta<betaStop || nc<4) && nc<fNclustMax);
-
-       Int_t *xx=new Int_t[fNeff];
-       for (Int_t i = 0; i < fNeff; i++) xx[i] = 0;
-       
-       EndDetAnn(nk,xData,xx,dEtSum,vPx,vPy,mPyx,mY);
-       StoreJets(nk,xData,xx,mY);
-       delete [] xx;
+  // Find the jets in current event
+  //
+  Float_t betaStop=100.;
+  fDebug = fHeader->GetDebug();
+
+  Double_t dEtSum=0;
+  Double_t *xData[2];
+  TVectorD *vPx = new TVectorD();
+  TVectorD *vPy = new TVectorD();
+  TMatrixD *mPyx= new TMatrixD();
+  TMatrixD *mY  = new TMatrixD();
+  InitDetAnn(dEtSum,xData,vPx,vPy,mPyx,mY);
+  if (fNin < fNclustMax){
+    delete [] xData[0], delete [] xData[1];
+    delete vPx;
+    delete vPy;
+    delete mPyx;
+    delete mY;
+    return;
+  }
+  Int_t nc=1, nk;
+  DoubleClusters(nc,nk,vPy,mY);
+  do{                                  //loop over beta
+    fBeta*=fAlpha;
+    Annealing(nk,xData,vPx,vPy,mPyx,mY);
+    NumCl(nc,nk,vPy,mPyx,mY);
+  }while((fBeta<betaStop || nc<4) && nc<fNclustMax);
 
-       delete [] xData[0], delete [] xData[1];
-       delete mPyx;
-       delete mY;
-       delete vPx;
-       delete vPy;
+  Int_t *xx=new Int_t[fNeff];
+  for (Int_t i = 0; i < fNeff; i++) xx[i] = 0;
+
+  EndDetAnn(nk,xData,xx,dEtSum,vPx,vPy,mPyx,mY);
+  StoreJets(nk,xData,xx,mY);
+  delete [] xx;
+
+  delete [] xData[0], delete [] xData[1];
+  delete mPyx;
+  delete mY;
+  delete vPx;
+  delete vPy;
 
 }
 
 //-----------------------------------------------------------------------------------
 void AliDAJetFinder::InitDetAnn(Double_t &dEtSum,Double_t **xData,TVectorD *vPx,TVectorD *vPy,TMatrixD *mPyx,TMatrixD *mY)
 {
-//Initialise the variables used by the algorithm
-       fBeta=0.1;
-       fNclustMax = ((AliDAJetHeader*)fHeader)->GetFixedCl() ? 
-           ((AliDAJetHeader*)fHeader)->GetNclustMax() : 
-           TMath::Max((Int_t)TMath::Sqrt(fNin),5);
-       Float_t etaEff = ((AliDAJetHeader*)fHeader)->GetEtaEff();
-       TClonesArray *lvArray = fReader->GetMomentumArray();
-       Int_t nEntr = lvArray->GetEntries();
-       fNin=0;
-       for (Int_t iEn=0; iEn<nEntr; iEn++) if (fReader->GetCutFlag(iEn)==1) fNin++;
-
-       fNeff = ((AliDAJetHeader*)fHeader)->GetNeff();
-       fNeff = TMath::Max(fNeff,fNin);
-       Double_t *xEta = new Double_t[fNeff];
-       Double_t *xPhi = new Double_t[fNeff];
-       xData[0]=xEta; xData[1]=xPhi;
-       vPx->ResizeTo(fNeff);
-       Int_t iIn=0;
-       for (Int_t iEn=0; iEn<nEntr; iEn++){
-               if (fReader->GetCutFlag(iEn)==0) continue;
-               TLorentzVector *lv=(TLorentzVector*)lvArray->At(iEn);
-               xEta[iIn] = lv->Eta();
-               xPhi[iIn] = lv->Phi()<0 ? lv->Phi() + 2*TMath::Pi() : lv->Phi();
-               (*vPx)(iIn)=lv->Pt();
-               dEtSum+=(*vPx)(iIn);
-               iIn++;
-       }
-       TRandom2 r;
-       r.SetSeed(0);
-       for (iIn=fNin; iIn<fNeff; iIn++){
-               xEta[iIn]=r.Uniform(-1*etaEff,etaEff);
-               xPhi[iIn]=r.Uniform(0.,2*TMath::Pi());
-               (*vPx)(iIn)=r.Uniform(0.01,0.02);
-               dEtSum+=(*vPx)(iIn);
-       }
-       for (iIn=0; iIn<fNeff; iIn++) (*vPx)(iIn)=(*vPx)(iIn)/dEtSum;
-
-       Int_t njdim=2*fNclustMax+1;
-       mPyx->ResizeTo(fNeff,njdim);
-       mY->ResizeTo(4,njdim);
-       vPy->ResizeTo(njdim);
-       mY->Zero();mPyx->Zero();vPy->Zero();
-       (*vPy)(0)=1;
-       TMatrixDColumn(*mPyx,0)=1;
-       Double_t ypos=0,xpos=0;
-       for (iIn=0; iIn<fNeff; iIn++){
-               (*mY)(0,0)+=(*vPx)(iIn)*xEta[iIn];
-               ypos+=(*vPx)(iIn)*TMath::Sin(xPhi[iIn]);
-               xpos+=(*vPx)(iIn)*TMath::Cos(xPhi[iIn]);
-       }
-       (*mY)(1,0)=(atan2(ypos,xpos)>0) ? atan2(ypos,xpos) : atan2(ypos,xpos)+2*TMath::Pi();
+  //Initialise the variables used by the algorithm
+  fBeta=0.1;
+  fNclustMax = ((AliDAJetHeader*)fHeader)->GetFixedCl() ?
+    ((AliDAJetHeader*)fHeader)->GetNclustMax() :
+    TMath::Max((Int_t)TMath::Sqrt(fNin),5);
+  Float_t etaEff = ((AliDAJetHeader*)fHeader)->GetEtaEff();
+
+  fNin=0;
+  for (Int_t iTr=0; iTr<GetCalTrkEvent()->GetNCalTrkTracks(); iTr++) if (GetCalTrkEvent()->GetCalTrkTrack(iTr)->GetCutFlag()==1) fNin++;
+
+  fNeff = ((AliDAJetHeader*)fHeader)->GetNeff();
+  fNeff = TMath::Max(fNeff,fNin);
+  Double_t *xEta = new Double_t[fNeff];
+  Double_t *xPhi = new Double_t[fNeff];
+  xData[0]=xEta; xData[1]=xPhi;
+  vPx->ResizeTo(fNeff);
+  Int_t iIn=0;
+
+  for (Int_t iTr=0; iTr<GetCalTrkEvent()->GetNCalTrkTracks(); iTr++){
+    AliJetCalTrkTrack* ctT = GetCalTrkEvent()->GetCalTrkTrack(iTr);
+    if (ctT->GetCutFlag()==0) continue;
+    xEta[iIn] = ctT->GetEta();
+    xPhi[iIn] = ctT->GetPhi()<0 ? ctT->GetPhi() + 2*TMath::Pi() : ctT->GetPhi();
+    (*vPx)(iIn)=ctT->GetPt();
+    dEtSum+=(*vPx)(iIn);
+    iIn++;
+  }
+
+  TRandom2 r;
+  r.SetSeed(0);
+  for (iIn=fNin; iIn<fNeff; iIn++){
+    xEta[iIn]=r.Uniform(-1*etaEff,etaEff);
+    xPhi[iIn]=r.Uniform(0.,2*TMath::Pi());
+    (*vPx)(iIn)=r.Uniform(0.01,0.02);
+    dEtSum+=(*vPx)(iIn);
+  }
+  for (iIn=0; iIn<fNeff; iIn++) (*vPx)(iIn)=(*vPx)(iIn)/dEtSum;
+
+  Int_t njdim=2*fNclustMax+1;
+  mPyx->ResizeTo(fNeff,njdim);
+  mY->ResizeTo(4,njdim);
+  vPy->ResizeTo(njdim);
+  mY->Zero();mPyx->Zero();vPy->Zero();
+  (*vPy)(0)=1;
+  TMatrixDColumn(*mPyx,0)=1;
+  Double_t ypos=0,xpos=0;
+  for (iIn=0; iIn<fNeff; iIn++){
+    (*mY)(0,0)+=(*vPx)(iIn)*xEta[iIn];
+    ypos+=(*vPx)(iIn)*TMath::Sin(xPhi[iIn]);
+    xpos+=(*vPx)(iIn)*TMath::Cos(xPhi[iIn]);
+  }
+  (*mY)(1,0)=(atan2(ypos,xpos)>0) ? atan2(ypos,xpos) : atan2(ypos,xpos)+2*TMath::Pi();
+
 }
 
 //-----------------------------------------------------------------------------------
-void AliDAJetFinder::DoubleClusters(Int_t nc,Int_t &nk,  TVectorD *vPy, TMatrixD *mY) const
+void AliDAJetFinder::DoubleClusters(Int_t nc,Int_t &nk, TVectorD *vPy, TMatrixD *mY) const
 {
-// Return double clusters
-       for(Int_t iClust=0; iClust<nc; iClust++){
-               (*vPy)(iClust)=(*vPy)(iClust)/2;
-               (*vPy)(nc+iClust)=(*vPy)(iClust);
-               for(Int_t iComp=0; iComp<3; iComp++) (*mY)(iComp,nc+iClust)=(*mY)(iComp,iClust);
-       }
-       nk=2*nc;
+  // Return double clusters
+  for(Int_t iClust=0; iClust<nc; iClust++){
+    (*vPy)(iClust)=(*vPy)(iClust)/2;
+    (*vPy)(nc+iClust)=(*vPy)(iClust);
+    for(Int_t iComp=0; iComp<3; iComp++) (*mY)(iComp,nc+iClust)=(*mY)(iComp,iClust);
+  }
+  nk=2*nc;
+
 }
 
 //-----------------------------------------------------------------------------------
-void AliDAJetFinder::Annealing(Int_t nk,Double_t **xData,  TVectorD *vPx,  TVectorD *vPy,  TMatrixD *mPyx,  TMatrixD *mY)
+void AliDAJetFinder::Annealing(Int_t nk,Double_t **xData,  const TVectorD *vPx,  TVectorD *vPy,  TMatrixD *mPyx,  TMatrixD *mY)
 {
-// Main part of the algorithm
-       const Double_t pi=TMath::Pi();
-       TVectorD *py = new TVectorD(nk);
-       TVectorD *p  = new TVectorD(nk);
-       TMatrixD *y  = new TMatrixD(4,nk);
-       TMatrixD *y1 = new TMatrixD(4,nk);
-       TMatrixD *ry = new TMatrixD(2,nk);
-       Double_t *xEta = xData[0];
-       Double_t *xPhi = xData[1];
-       Double_t Dist(TVectorD,TVectorD);
-
-       Double_t df[2]={fReader->GetReaderHeader()->GetFiducialEtaMax(),pi};
-       TVectorD vPart(2);
-       Double_t *m = new Double_t[nk];
-       Double_t chi,chi1;
-       do{
-               Int_t nloop=0;
-               for (Int_t iClust=0; iClust<nk; iClust++){
-                       for (Int_t i=0; i<3; i++)(*y1)(i,iClust)=(*mY)(i,iClust);
-                       (*py)(iClust)=(*vPy)(iClust);
-               }
-       //perturbation of codevectors
-               Double_t seed=1000000*gRandom->Rndm(24);
-               ry->Randomize(-0.5,0.5,seed);
-               for (Int_t i=0; i<2; i++){
-                       for (Int_t iClust=0; iClust<nk/2; iClust++)
-                               (*y1)(i,iClust)+=((*ry)(i,iClust)+TMath::Sign(0.5,(*ry)(i,iClust)))*fDelta*df[i];
-                       for (Int_t iClust=nk/2; iClust<nk; iClust++)
-                               (*y1)(i,iClust)-=((*ry)(i,iClust-nk/2)+TMath::Sign(0.5,(*ry)(i,iClust-nk/2)))*fDelta*df[i];
-               }
-               do{
-       //recalculate conditional probabilities
-                       nloop++;
-                       for (Int_t iIn=0; iIn<fNeff; iIn++){
-                               vPart(0)=xEta[iIn]; vPart(1)=xPhi[iIn];
-                               for(Int_t iClust=0; iClust<nk; iClust++){
-                                       (*mPyx)(iIn,iClust)=-log((*py)(iClust))+fBeta*Dist(vPart,TMatrixDColumn(*y1,iClust));
-                                       m[iClust]=(*mPyx)(iIn,iClust);
-                               }
-                               Double_t pyxNorm=0;
-                               Double_t minPyx=TMath::MinElement(nk,m);
-                               for (Int_t iClust=0; iClust<nk; iClust++){
-                                       (*mPyx)(iIn,iClust)-=minPyx;
-                                       (*mPyx)(iIn,iClust)=exp(-(*mPyx)(iIn,iClust));
-                                       pyxNorm+=(*mPyx)(iIn,iClust);
-                               }
-                               for (Int_t iClust=0; iClust<nk; iClust++) (*mPyx)(iIn,iClust)/=pyxNorm;
-                       }
-                       p->Zero();
-                       y->Zero();
-       //recalculate codevectors
-                       for (Int_t iClust=0; iClust<nk; iClust++){
-                               Double_t xpos=0,ypos=0,pxy;
-                               for (Int_t iIn=0; iIn<fNeff; iIn++) (*p)(iClust)+=(*vPx)(iIn)*(*mPyx)(iIn,iClust);
-                               for (Int_t iIn=0; iIn<fNeff; iIn++){
-                                       pxy=(*vPx)(iIn)*(*mPyx)(iIn,iClust)/(*p)(iClust);
-                                       ypos+=pxy*TMath::Sin(xPhi[iIn]);
-                                       xpos+=pxy*TMath::Cos(xPhi[iIn]);
-                                       (*y)(0,iClust)+=pxy*xEta[iIn];
-                               }
-                               (*y)(1,iClust)=(atan2(ypos,xpos)>0) ? atan2(ypos,xpos) : atan2(ypos,xpos)+2*pi;
-                       }
-       //verify codevectors' stability
-                       chi=0;
-                       for (Int_t iClust=0; iClust<nk; iClust++){
-                               chi1=TMath::CosH((*y1)(0,iClust)-(*y)(0,iClust))-TMath::Cos((*y1)(1,iClust)-(*y)(1,iClust));
-                               chi1/=(2*TMath::CosH((*y1)(0,iClust))*TMath::CosH((*y)(0,iClust)));
-                               chi1*=chi1;
-                               if (chi1>chi) chi=chi1;
-                       }
-                       chi=TMath::Sqrt(chi);
-                       for (Int_t iClust=0; iClust<nk; iClust++){
-                               for (Int_t i=0; i<2; i++) (*y1)(i,iClust)=(*y)(i,iClust);
-                               (*py)(iClust)=(*p)(iClust);
-                       }
-                       if (nloop>fNloopMax){
-                               if (chi<fEpsMax || nloop>500) break;
-                       }
-               }while (chi>fEps);
-       }while (chi>fEpsMax);
-       for (Int_t iClust=0; iClust<nk; iClust++){                              //set codevectors and probability equal to those calculated
-               for (Int_t i=0; i<2; i++) (*mY)(i,iClust)=(*y)(i,iClust);
-               (*vPy)(iClust)=(*p)(iClust);
+  // Main part of the algorithm
+  const Double_t pi=TMath::Pi();
+  TVectorD *py = new TVectorD(nk);
+  TVectorD *p  = new TVectorD(nk);
+  TMatrixD *y  = new TMatrixD(4,nk);
+  TMatrixD *y1 = new TMatrixD(4,nk);
+  TMatrixD *ry = new TMatrixD(2,nk);
+  Double_t *xEta = xData[0];
+  Double_t *xPhi = xData[1];
+  Double_t Dist(TVectorD,TVectorD);
+
+  Double_t df[2]={((AliDAJetHeader*)fHeader)->GetFiducialEtaMax(),pi};
+  TVectorD vPart(2);
+  Double_t *m = new Double_t[nk];
+  Double_t chi,chi1;
+  do{
+    Int_t nloop=0;
+    for (Int_t iClust=0; iClust<nk; iClust++){
+      for (Int_t i=0; i<3; i++)(*y1)(i,iClust)=(*mY)(i,iClust);
+      (*py)(iClust)=(*vPy)(iClust);
+    }
+    //perturbation of codevectors
+    Double_t seed=1000000*gRandom->Rndm(24);
+    ry->Randomize(-0.5,0.5,seed);
+    for (Int_t i=0; i<2; i++){
+      for (Int_t iClust=0; iClust<nk/2; iClust++)
+       (*y1)(i,iClust)+=((*ry)(i,iClust)+TMath::Sign(0.5,(*ry)(i,iClust)))*fDelta*df[i];
+      for (Int_t iClust=nk/2; iClust<nk; iClust++)
+       (*y1)(i,iClust)-=((*ry)(i,iClust-nk/2)+TMath::Sign(0.5,(*ry)(i,iClust-nk/2)))*fDelta*df[i];
+    }
+    do{
+      //recalculate conditional probabilities
+      nloop++;
+      for (Int_t iIn=0; iIn<fNeff; iIn++){
+       vPart(0)=xEta[iIn]; vPart(1)=xPhi[iIn];
+       for(Int_t iClust=0; iClust<nk; iClust++){
+         (*mPyx)(iIn,iClust)=-log((*py)(iClust))+fBeta*Dist(vPart,TMatrixDColumn(*y1,iClust));
+         m[iClust]=(*mPyx)(iIn,iClust);
        }
-    delete py;
-    delete p;
-    delete y;
-    delete y1;
-    delete ry;
-    delete [] m;
+       Double_t pyxNorm=0;
+       Double_t minPyx=TMath::MinElement(nk,m);
+       for (Int_t iClust=0; iClust<nk; iClust++){
+         (*mPyx)(iIn,iClust)-=minPyx;
+         (*mPyx)(iIn,iClust)=exp(-(*mPyx)(iIn,iClust));
+         pyxNorm+=(*mPyx)(iIn,iClust);
+       }
+       for (Int_t iClust=0; iClust<nk; iClust++) (*mPyx)(iIn,iClust)/=pyxNorm;
+      }
+      p->Zero();
+      y->Zero();
+      //recalculate codevectors
+      for (Int_t iClust=0; iClust<nk; iClust++){
+       Double_t xpos=0,ypos=0,pxy;
+       for (Int_t iIn=0; iIn<fNeff; iIn++) (*p)(iClust)+=(*vPx)(iIn)*(*mPyx)(iIn,iClust);
+       for (Int_t iIn=0; iIn<fNeff; iIn++){
+         pxy=(*vPx)(iIn)*(*mPyx)(iIn,iClust)/(*p)(iClust);
+         ypos+=pxy*TMath::Sin(xPhi[iIn]);
+         xpos+=pxy*TMath::Cos(xPhi[iIn]);
+         (*y)(0,iClust)+=pxy*xEta[iIn];
+       }
+       (*y)(1,iClust)=(atan2(ypos,xpos)>0) ? atan2(ypos,xpos) : atan2(ypos,xpos)+2*pi;
+      }
+      //verify codevectors' stability
+      chi=0;
+      for (Int_t iClust=0; iClust<nk; iClust++){
+       chi1=TMath::CosH((*y1)(0,iClust)-(*y)(0,iClust))-TMath::Cos((*y1)(1,iClust)-(*y)(1,iClust));
+       chi1/=(2*TMath::CosH((*y1)(0,iClust))*TMath::CosH((*y)(0,iClust)));
+       chi1*=chi1;
+       if (chi1>chi) chi=chi1;
+      }
+      chi=TMath::Sqrt(chi);
+      for (Int_t iClust=0; iClust<nk; iClust++){
+       for (Int_t i=0; i<2; i++) (*y1)(i,iClust)=(*y)(i,iClust);
+       (*py)(iClust)=(*p)(iClust);
+      }
+      if (nloop>fNloopMax){
+       if (chi<fEpsMax || nloop>500) break;
+      }
+    }while (chi>fEps);
+  }while (chi>fEpsMax);
+  for (Int_t iClust=0; iClust<nk; iClust++){                           //set codevectors and probability equal to those calculated
+    for (Int_t i=0; i<2; i++) (*mY)(i,iClust)=(*y)(i,iClust);
+    (*vPy)(iClust)=(*p)(iClust);
+  }
+  delete py;
+  delete p;
+  delete y;
+  delete y1;
+  delete ry;
+  delete [] m;
+
 }
 
 //-----------------------------------------------------------------------------------
-void AliDAJetFinder::NumCl(Int_t &nc,Int_t &nk,TVectorD *vPy,  TMatrixD *mPyx,TMatrixD *mY)
+void AliDAJetFinder::NumCl(Int_t &nc,Int_t &nk,TVectorD *vPy, TMatrixD *mPyx,TMatrixD *mY)
 {
-    // Number of clusters
-       static Bool_t growcl=true;
+  // Number of clusters
+  static Bool_t growcl=true;
        
-       if (nk==2) growcl=true;
-       if (growcl){
-//verify if two codevectors are equal within fAvDist
-               Int_t *nSame = new Int_t[nk];
-               Int_t **iSame = new Int_t*[nk];
-               Int_t **cont = new Int_t*[nk];
-               for (Int_t iClust=0; iClust<nk; iClust++) {
-                   cont[iClust] =new Int_t[nk];
-                   iSame[iClust]=new Int_t[nk];
-               }
-               
-               for (Int_t iClust=0; iClust<nk; iClust++){
-                       iSame[iClust][iClust]=1;
-                       for (Int_t iClust1=iClust+1; iClust1<nk; iClust1++){
-                               Double_t eta  = (*mY)(0,iClust) ; Double_t phi  = (*mY)(1,iClust);
-                               Double_t eta1 = (*mY)(0,iClust1); Double_t phi1 = (*mY)(1,iClust1);
-                               Double_t distCl=(TMath::CosH(eta-eta1)-TMath::Cos(phi-phi1))/(2*TMath::CosH(eta)*TMath::CosH(eta1));
-                               if (distCl < fAvDist) iSame[iClust][iClust1]=iSame[iClust1][iClust]=1;
-                               else iSame[iClust][iClust1]=iSame[iClust1][iClust]=0;
-                       }
-               }
-               ReduceClusters(iSame,nk,nc,cont,nSame);
-               if (nc >= fNclustMax) growcl=false;
-//recalculate the nc distinct codevectors
-               TMatrixD *pyx = new TMatrixD(fNeff,2*nc);
-               TVectorD *py = new TVectorD(nk);
-               TMatrixD *y1  = new TMatrixD(3,nk);
-               for (Int_t iClust=0; iClust<nc; iClust++){
-                       for(Int_t j=0; j<nSame[iClust]; j++){
-                               Int_t iClust1 = cont[iClust][j];
-                               for (Int_t iIn=0; iIn<fNeff; iIn++) (*pyx)(iIn,iClust)+=(*mPyx)(iIn,iClust1);
-                               (*py)(iClust)+=(*vPy)(iClust1);
-                               for (Int_t i=0; i<2; i++) (*y1)(i,iClust)+=(*mY)(i,iClust1);
-                       }
-                       for (Int_t i=0; i<2; i++) (*y1)(i,iClust)/=nSame[iClust];
-               }
-               for (Int_t iClust=0; iClust<nk; iClust++) delete [] cont[iClust], delete [] iSame[iClust];
-               delete [] iSame;
-               delete [] cont;
-               delete [] nSame;
-               if (nc > nk/2){
-                       for (Int_t iClust=0; iClust<nc; iClust++){
-                               for (Int_t iIn=0; iIn<fNeff; iIn++) (*mPyx)(iIn,iClust)=(*pyx)(iIn,iClust);
-                               for (Int_t iComp=0; iComp<2; iComp++) (*mY)(iComp,iClust)=(*y1)(iComp,iClust);
-                               (*vPy)(iClust)=(*py)(iClust);
-                       }
-                       nk=nc;
-                       if (growcl) DoubleClusters(nc,nk,vPy,mY);
-               }
-               delete pyx;
-               delete py;
-               delete y1;
-       }
+  if (nk==2) growcl=true;
+  if (growcl){
+    //verify if two codevectors are equal within fAvDist
+    Int_t *nSame = new Int_t[nk];
+    Int_t **iSame = new Int_t*[nk];
+    Int_t **cont = new Int_t*[nk];
+    for (Int_t iClust=0; iClust<nk; iClust++) {
+      cont[iClust] =new Int_t[nk];
+      iSame[iClust]=new Int_t[nk];         
+    }
+
+    for (Int_t iClust=0; iClust<nk; iClust++){
+      iSame[iClust][iClust]=1;
+      for (Int_t iClust1=iClust+1; iClust1<nk; iClust1++){
+       Double_t eta  = (*mY)(0,iClust) ; Double_t phi  = (*mY)(1,iClust);
+       Double_t eta1 = (*mY)(0,iClust1); Double_t phi1 = (*mY)(1,iClust1);
+       Double_t distCl=(TMath::CosH(eta-eta1)-TMath::Cos(phi-phi1))/(2*TMath::CosH(eta)*TMath::CosH(eta1));
+       if (distCl < fAvDist) iSame[iClust][iClust1]=iSame[iClust1][iClust]=1;
+       else iSame[iClust][iClust1]=iSame[iClust1][iClust]=0;
+      }
+    }
+    ReduceClusters(iSame,nk,nc,cont,nSame);
+    if (nc >= fNclustMax) growcl=false;
+    //recalculate the nc distinct codevectors
+    TMatrixD *pyx = new TMatrixD(fNeff,2*nc);
+    TVectorD *py = new TVectorD(nk);
+    TMatrixD *y1  = new TMatrixD(3,nk);
+    for (Int_t iClust=0; iClust<nc; iClust++){
+      for(Int_t j=0; j<nSame[iClust]; j++){
+       Int_t iClust1 = cont[iClust][j];
+       for (Int_t iIn=0; iIn<fNeff; iIn++) (*pyx)(iIn,iClust)+=(*mPyx)(iIn,iClust1);
+       (*py)(iClust)+=(*vPy)(iClust1);
+       for (Int_t i=0; i<2; i++) (*y1)(i,iClust)+=(*mY)(i,iClust1);
+      }
+      for (Int_t i=0; i<2; i++) (*y1)(i,iClust)/=nSame[iClust];
+    }
+    for (Int_t iClust=0; iClust<nk; iClust++) delete [] cont[iClust], delete [] iSame[iClust];
+    delete [] iSame;
+    delete [] cont;
+    delete [] nSame;
+    if (nc > nk/2){
+      for (Int_t iClust=0; iClust<nc; iClust++){
+       for (Int_t iIn=0; iIn<fNeff; iIn++) (*mPyx)(iIn,iClust)=(*pyx)(iIn,iClust);
+       for (Int_t iComp=0; iComp<2; iComp++) (*mY)(iComp,iClust)=(*y1)(iComp,iClust);
+       (*vPy)(iClust)=(*py)(iClust);
+      }
+      nk=nc;
+      if (growcl) DoubleClusters(nc,nk,vPy,mY);
+    }
+    delete pyx;
+    delete py;
+    delete y1;
+  }
 
 }
 
 //-----------------------------------------------------------------------------------
 void AliDAJetFinder::ReduceClusters(Int_t **iSame,Int_t nc,Int_t &ncout,Int_t **cont,Int_t *nSameOut) const
 {
-// Reduction step
-       Int_t *nSame = new Int_t[nc];
-       Int_t *iperm = new Int_t[nc];
-       Int_t *go = new Int_t[nc];
-       for (Int_t iCl=0; iCl<nc; iCl++){
-               nSame[iCl]=0;
-               for (Int_t jCl=0; jCl<nc; jCl++) nSame[iCl]+=iSame[iCl][jCl], cont[iCl][jCl]=0;
-               iperm[iCl]=iCl;
-               go[iCl]=1;
-       }
-       TMath::Sort(nc,nSame,iperm,true);
-       Int_t l=0;
-       for (Int_t iCl=0; iCl<nc; iCl++){
-               Int_t k=iperm[iCl];
-               if (go[k] == 1){
-                       Int_t m=0;
-                       for (Int_t jCl=0; jCl<nc; jCl++){
-                               if (iSame[k][jCl] == 1){
-                                       cont[l][m]=jCl;
-                                       go[jCl]=0;
-                                       m++;
-                               }
-                       }
-                       nSameOut[l]=m;
-                       l++;
-               }
+  // Reduction step
+  Int_t *nSame = new Int_t[nc];
+  Int_t *iperm = new Int_t[nc];
+  Int_t *go = new Int_t[nc];
+  for (Int_t iCl=0; iCl<nc; iCl++){
+    nSame[iCl]=0;
+    for (Int_t jCl=0; jCl<nc; jCl++) nSame[iCl]+=iSame[iCl][jCl], cont[iCl][jCl]=0;
+    iperm[iCl]=iCl;
+    go[iCl]=1;
+  }
+  TMath::Sort(nc,nSame,iperm,true);
+  Int_t l=0;
+  for (Int_t iCl=0; iCl<nc; iCl++){
+    Int_t k=iperm[iCl];
+    if (go[k] == 1){
+      Int_t m=0;
+      for (Int_t jCl=0; jCl<nc; jCl++){
+       if (iSame[k][jCl] == 1){
+         cont[l][m]=jCl;
+         go[jCl]=0;
+         m++;
        }
-       ncout=l;
-       delete [] nSame;
-       delete [] iperm;
-       delete [] go;
+      }
+      nSameOut[l]=m;
+      l++;
+    }
+  }
+  ncout=l;
+  delete [] nSame;
+  delete [] iperm;
+  delete [] go;
+
 }
 
 //-----------------------------------------------------------------------------------
-void AliDAJetFinder::EndDetAnn(Int_t &nk,Double_t **xData,Int_t *xx,Double_t etx,TVectorD *vPx,TVectorD *vPy,TMatrixD *mPyx,TMatrixD *mY)
+void AliDAJetFinder::EndDetAnn(Int_t &nk,Double_t **xData,Int_t *xx,Double_t etx,const TVectorD *vPx,TVectorD *vPy,TMatrixD *mPyx,TMatrixD *mY)
 {
-//now assign each particle to only one cluster
-       Double_t *clusters=new Double_t[nk];
-       for (Int_t iIn=0; iIn<fNeff; iIn++){
-               for (Int_t iClust=0; iClust<nk; iClust++) clusters[iClust]=(*mPyx)(iIn,iClust);
-               xx[iIn]=TMath::LocMax(nk,clusters);
-       }
-       delete [] clusters;
+  //now assign each particle to only one cluster
+  Double_t *clusters=new Double_t[nk];
+  for (Int_t iIn=0; iIn<fNeff; iIn++){
+    for (Int_t iClust=0; iClust<nk; iClust++) clusters[iClust]=(*mPyx)(iIn,iClust);
+    xx[iIn]=TMath::LocMax(nk,clusters);
+  }
+  delete [] clusters;
        
-//recalculate codevectors, having all p(y|x)=0 or 1
-       Double_t *xEta = xData[0];
-       Double_t *xPhi = xData[1];
-       mY->Zero();
-       mPyx->Zero();
-       vPy->Zero();
-       for (Int_t iIn=0; iIn<fNin; iIn++){
-               Int_t iClust=xx[iIn];
-               (*mPyx)(iIn,iClust)=1;
-               (*vPy)(iClust)+=(*vPx)(iIn);
-               (*mY)(0,iClust)+=(*vPx)(iIn)*xEta[iIn];
-               (*mY)(3,iClust)+=(*vPx)(iIn)*etx;
-       }
-       Int_t k=0;
-       for (Int_t iClust=0; iClust<nk; iClust++){
-               if ((*vPy)(iClust)>0){
-                       Double_t xpos=0,ypos=0,pxy;
-                       for (Int_t iIn=0; iIn<fNin; iIn++){
-                               pxy=(*vPx)(iIn)*(*mPyx)(iIn,iClust)/(*vPy)(iClust);
-                               ypos+=pxy*TMath::Sin(xPhi[iIn]);
-                               xpos+=pxy*TMath::Cos(xPhi[iIn]);
-                               if (xx[iIn]==iClust) xx[iIn]=k;
-                       }
-                       (*mY)(0,k)=(*mY)(0,iClust)/(*vPy)(iClust);
-                       (*mY)(1,k)=(atan2(ypos,xpos)>0) ? atan2(ypos,xpos) : atan2(ypos,xpos)+2*TMath::Pi();
-                       (*mY)(3,k)=(*mY)(3,iClust);
-                       k++;
-               }
-       }
-       nk=k;
+  //recalculate codevectors, having all p(y|x)=0 or 1
+  Double_t *xEta = xData[0];
+  Double_t *xPhi = xData[1];
+  mY->Zero();
+  mPyx->Zero();
+  vPy->Zero();
+  for (Int_t iIn=0; iIn<fNin; iIn++){
+    Int_t iClust=xx[iIn];
+    (*mPyx)(iIn,iClust)=1;
+    (*vPy)(iClust)+=(*vPx)(iIn);
+    (*mY)(0,iClust)+=(*vPx)(iIn)*xEta[iIn];
+    (*mY)(3,iClust)+=(*vPx)(iIn)*etx;
+  }
+  Int_t k=0;
+  for (Int_t iClust=0; iClust<nk; iClust++){
+    if ((*vPy)(iClust)>0){
+      Double_t xpos=0,ypos=0,pxy;
+      for (Int_t iIn=0; iIn<fNin; iIn++){
+       pxy=(*vPx)(iIn)*(*mPyx)(iIn,iClust)/(*vPy)(iClust);
+       ypos+=pxy*TMath::Sin(xPhi[iIn]);
+       xpos+=pxy*TMath::Cos(xPhi[iIn]);
+       if (xx[iIn]==iClust) xx[iIn]=k;
+      }
+      (*mY)(0,k)=(*mY)(0,iClust)/(*vPy)(iClust);
+      (*mY)(1,k)=(atan2(ypos,xpos)>0) ? atan2(ypos,xpos) : atan2(ypos,xpos)+2*TMath::Pi();
+      (*mY)(3,k)=(*mY)(3,iClust);
+      k++;
+    }
+  }
+  nk=k;
+
 }
 
 //-----------------------------------------------------------------------------------
-void AliDAJetFinder::StoreJets(Int_t nk, Double_t **xData, Int_t *xx, TMatrixD *mY)
+void AliDAJetFinder::StoreJets(Int_t nk, Double_t **xData, const Int_t *xx, const TMatrixD *mY)
 {
-//evaluate significant clusters properties
-       const Double_t pi=TMath::Pi();
-       AliJetReaderHeader *rHeader=fReader->GetReaderHeader();
-       Float_t dFidEtaMax = rHeader->GetFiducialEtaMax();
-       Float_t dFidEtaMin = rHeader->GetFiducialEtaMin();
-       Float_t dFiducialEta= dFidEtaMax - dFidEtaMin;
-       Double_t *xEta = xData[0];
-       Double_t *xPhi = xData[1];
-       Int_t nEff = 0;
-       for (Int_t i=0; i<fNeff; i++) if (xEta[i]<dFidEtaMax && xEta[i]>dFidEtaMin) nEff++;
-       Double_t dMeanDist=0.;
-       if (nEff > 0) 
-           dMeanDist=TMath::Sqrt(2*dFiducialEta*pi/nEff);
-       Bool_t   *isJet = new Bool_t[nk];
-       Double_t *etNoBg= new Double_t[nk];
-       Double_t *dDeltaEta=new Double_t[nk];
-       Double_t *dDeltaPhi=new Double_t[nk];
-       Double_t *surf  = new Double_t[nk];
-       Double_t *etDens= new Double_t[nk];
-       for (Int_t iClust=0; iClust<nk; iClust++){
-               isJet[iClust]=false;
-               Double_t dEtaMin=10.,dEtaMax=-10.,dPhiMin=10.,dPhiMax=0.;
-               for (Int_t iIn=0; iIn<fNeff; iIn++){
-                       if (xx[iIn]!=iClust || xEta[iIn]>dFidEtaMax || xEta[iIn]<dFidEtaMin) continue;
-                       if (xEta[iIn] < dEtaMin) dEtaMin=xEta[iIn];
-                       if (xEta[iIn] > dEtaMax) dEtaMax=xEta[iIn];
-                       Double_t dPhi=xPhi[iIn]-(*mY)(1,iClust);
-                       if      (dPhi > pi     ) dPhi-=2*pi;
-                       else if (dPhi < (-1)*pi) dPhi+=2*pi;
-                       if      (dPhi < dPhiMin) dPhiMin=dPhi;
-                       else if (dPhi > dPhiMax) dPhiMax=dPhi;
-               }
-               dDeltaEta[iClust]=dEtaMax-dEtaMin+dMeanDist;
-               dDeltaPhi[iClust]=dPhiMax-dPhiMin+dMeanDist;
-               surf[iClust]=0.25*pi*dDeltaEta[iClust]*dDeltaPhi[iClust];
-               etDens[iClust]=(*mY)(3,iClust)/surf[iClust];
-       }
+  //evaluate significant clusters properties
+  const Double_t pi=TMath::Pi();
+  Float_t dFidEtaMax = ((AliDAJetHeader*)fHeader)->GetFiducialEtaMax();
+  Float_t dFidEtaMin = ((AliDAJetHeader*)fHeader)->GetFiducialEtaMin();
+  Float_t dFiducialEta= dFidEtaMax - dFidEtaMin;
+  Double_t *xEta = xData[0];
+  Double_t *xPhi = xData[1];
+  Int_t nEff = 0;
+  for (Int_t i=0; i<fNeff; i++) if (xEta[i]<dFidEtaMax && xEta[i]>dFidEtaMin) nEff++;
+  Double_t dMeanDist=0.;
+  if (nEff > 0)
+    dMeanDist=TMath::Sqrt(2*dFiducialEta*pi/nEff);
+  Bool_t   *isJet = new Bool_t[nk];
+  Double_t *etNoBg= new Double_t[nk];
+  Double_t *dDeltaEta=new Double_t[nk];
+  Double_t *dDeltaPhi=new Double_t[nk];
+  Double_t *surf  = new Double_t[nk];
+  Double_t *etDens= new Double_t[nk];
+  for (Int_t iClust=0; iClust<nk; iClust++){
+    isJet[iClust]=false;
+    Double_t dEtaMin=10.,dEtaMax=-10.,dPhiMin=10.,dPhiMax=0.;
+    for (Int_t iIn=0; iIn<fNeff; iIn++){
+      if (xx[iIn]!=iClust || xEta[iIn]>dFidEtaMax || xEta[iIn]<dFidEtaMin) continue;
+      if (xEta[iIn] < dEtaMin) dEtaMin=xEta[iIn];
+      if (xEta[iIn] > dEtaMax) dEtaMax=xEta[iIn];
+      Double_t dPhi=xPhi[iIn]-(*mY)(1,iClust);
+      if      (dPhi > pi     ) dPhi-=2*pi;
+      else if (dPhi < (-1)*pi) dPhi+=2*pi;
+      if      (dPhi < dPhiMin) dPhiMin=dPhi;
+      else if (dPhi > dPhiMax) dPhiMax=dPhi;
+    }
+    dDeltaEta[iClust]=dEtaMax-dEtaMin+dMeanDist;
+    dDeltaPhi[iClust]=dPhiMax-dPhiMin+dMeanDist;
+    surf[iClust]=0.25*pi*dDeltaEta[iClust]*dDeltaPhi[iClust];
+    etDens[iClust]=(*mY)(3,iClust)/surf[iClust];
+  }
 
-       if (((AliDAJetHeader*)fHeader)->GetSelJets()){
-               for (Int_t iClust=0; iClust<nk; iClust++){
-                       if (!isJet[iClust] && (*mY)(0,iClust)<dFidEtaMax && (*mY)(0,iClust)>dFidEtaMin){
-                               Double_t etDensMed=0.;
-                               Double_t etDensSqr=0.;
-                               Int_t norm=0;
-                               for (Int_t iClust1=0; iClust1<nk; iClust1++){
-                                       if(iClust1!=iClust && (*mY)(0,iClust)<dFidEtaMax && (*mY)(0,iClust)>dFidEtaMin){
-                                               etDensMed+=etDens[iClust1];
-                                               etDensSqr+=TMath::Power(etDens[iClust1],2);
-                                               norm++;
-                                       }
-                               }
-                               etDensMed/=TMath::Max(norm,1);
-                               etDensSqr/=TMath::Max(norm,1);
-                               Double_t deltaEtDens=TMath::Sqrt(etDensSqr-TMath::Power(etDensMed,2));
-                               if ((*mY)(3,iClust) > (etDensMed+deltaEtDens)*surf[iClust]) isJet[iClust]=kTRUE;
-                               etNoBg[iClust]=(*mY)(3,iClust)-etDensMed*surf[iClust];
-                       }
-               }
-               for (Int_t iClust=0; iClust<nk; iClust++){
-                       if (isJet[iClust]){
-                               Double_t etDensMed=0;
-                               Double_t extSurf=2*dFiducialEta*pi;
-                               for (Int_t iClust1=0; iClust1<nk; iClust1++){
-                                       if (!isJet[iClust1]) etDensMed+=(*mY)(3,iClust1);
-                                       else extSurf-=surf[iClust1];
-                               }
-                               etDensMed/=extSurf;
-                               etNoBg[iClust]=(*mY)(3,iClust)-etDensMed*surf[iClust];
-                               if (etNoBg[iClust]<((AliDAJetHeader*)fHeader)->GetEtMin()){
-                                       isJet[iClust]=kFALSE;
-                                       iClust=-1;
-                               }
-                       }
-               }
-       } else {
-               for (Int_t iClust=0; iClust<nk; iClust++){
-                       isJet[iClust]=true;
-                       etNoBg[iClust]=(*mY)(3,iClust);
-               }
+  if (((AliDAJetHeader*)fHeader)->GetSelJets()){
+    for (Int_t iClust=0; iClust<nk; iClust++){
+      if (!isJet[iClust] && (*mY)(0,iClust)<dFidEtaMax && (*mY)(0,iClust)>dFidEtaMin){
+       Double_t etDensMed=0.;
+       Double_t etDensSqr=0.;
+       Int_t norm=0;
+       for (Int_t iClust1=0; iClust1<nk; iClust1++){
+         if(iClust1!=iClust && (*mY)(0,iClust)<dFidEtaMax && (*mY)(0,iClust)>dFidEtaMin){
+           etDensMed+=etDens[iClust1];
+           etDensSqr+=TMath::Power(etDens[iClust1],2);
+           norm++;
+         }
        }
-       delete [] etDens;
-       delete [] surf;
-       
-//now add selected jets to the list
-       Int_t *iSort = new Int_t[nk];
-       TMath::Sort(nk,etNoBg,iSort,true);
-       Int_t iCl = 0;
-       TRefArray *refs = 0;
-       Bool_t fromAod = !strcmp(fReader->ClassName(),"AliJetAODReader");
-       if (fromAod) refs = fReader->GetReferences();
-       for (Int_t iClust=0; iClust<nk; iClust++){                                                                      //clusters loop
-               iCl=iSort[iClust];
-               if (isJet[iCl]){                                                                                                                //choose cluster
-                       Float_t px,py,pz,en;
-                       px = (*mY)(3,iCl)*TMath::Cos((*mY)(1,iCl));
-                       py = (*mY)(3,iCl)*TMath::Sin((*mY)(1,iCl));
-                       pz = (*mY)(3,iCl)/TMath::Tan(2.0 * TMath::ATan(TMath::Exp(-(*mY)(0,iCl))));
-                       en = TMath::Sqrt(px * px + py * py + pz * pz);
-                       AliAODJet jet(px, py, pz, en);
-                       if (fromAod){
-                               Int_t iIn=0;
-                               Int_t nEntr = fReader->GetMomentumArray()->GetEntries();
-                               for (Int_t iEn=0; iEn<nEntr; iEn++){
-                                       if (fReader->GetCutFlag(iEn)==0) continue;
-                                       if (xx[iIn]==iCl) jet.AddTrack(refs->At(iEn));
-                                       iIn++;
-                               }
-                       }
-                       AddJet(jet);
-                       if (fDebug > 0) printf("jet %d, Eta: %f, Phi: %f, Et: %f\n",iCl,jet.Eta(),jet.Phi(),jet.Pt());
-               }
+       etDensMed/=TMath::Max(norm,1);
+       etDensSqr/=TMath::Max(norm,1);
+       Double_t deltaEtDens=TMath::Sqrt(etDensSqr-TMath::Power(etDensMed,2));
+       if ((*mY)(3,iClust) > (etDensMed+deltaEtDens)*surf[iClust]) isJet[iClust]=kTRUE;
+       etNoBg[iClust]=(*mY)(3,iClust)-etDensMed*surf[iClust];
+      }
+    }
+    for (Int_t iClust=0; iClust<nk; iClust++){
+      if (isJet[iClust]){
+       Double_t etDensMed=0;
+       Double_t extSurf=2*dFiducialEta*pi;
+       for (Int_t iClust1=0; iClust1<nk; iClust1++){
+         if (!isJet[iClust1]) etDensMed+=(*mY)(3,iClust1);
+         else extSurf-=surf[iClust1];
        }
-       delete [] dDeltaEta; delete [] dDeltaPhi;
-       delete [] etNoBg;
-       delete [] isJet;
-       delete [] iSort;
+       etDensMed/=extSurf;
+       etNoBg[iClust]=(*mY)(3,iClust)-etDensMed*surf[iClust];
+       if (etNoBg[iClust]<((AliDAJetHeader*)fHeader)->GetEtMin()){
+         isJet[iClust]=kFALSE;
+         iClust=-1;
+       }
+      }
+    }
+  } else {
+    for (Int_t iClust=0; iClust<nk; iClust++){
+      isJet[iClust]=true;
+      etNoBg[iClust]=(*mY)(3,iClust);
+    }
+  }
+  delete [] etDens;
+  delete [] surf;
+       
+  //now add selected jets to the list
+  Int_t *iSort = new Int_t[nk];
+  TMath::Sort(nk,etNoBg,iSort,true);
+  Int_t iCl = 0;
+
+  for (Int_t iClust=0; iClust<nk; iClust++){ //clusters loop
+    iCl=iSort[iClust];
+    if (isJet[iCl]){ //choose cluster
+      Float_t px,py,pz,en;
+      px = (*mY)(3,iCl)*TMath::Cos((*mY)(1,iCl));
+      py = (*mY)(3,iCl)*TMath::Sin((*mY)(1,iCl));
+      pz = (*mY)(3,iCl)/TMath::Tan(2.0 * TMath::ATan(TMath::Exp(-(*mY)(0,iCl))));
+      en = TMath::Sqrt(px * px + py * py + pz * pz);
+      AliAODJet jet(px, py, pz, en);
+      Int_t iIn=0;
+      Int_t nTr = GetCalTrkEvent()->GetNCalTrkTracks();
+      for (Int_t iTr=0; iTr<nTr; iTr++){
+       AliJetCalTrkTrack* ctT = GetCalTrkEvent()->GetCalTrkTrack(iTr);
+       if (ctT->GetCutFlag()==0) continue;
+       if (xx[iIn]==iCl) jet.AddTrack(ctT->GetTrackObject());
+       iIn++;
+      }
+      AddJet(jet);
+      if (fDebug > 0) printf("jet %d, Eta: %f, Phi: %f, Et: %f\n",iCl,jet.Eta(),jet.Phi(),jet.Pt());
+    }
+  }
+  delete [] dDeltaEta; delete [] dDeltaPhi;
+  delete [] etNoBg;
+  delete [] isJet;
+  delete [] iSort;
+
 }
 
 //-----------------------------------------------------------------------------------
 Double_t Dist(TVectorD x,TVectorD y)
 {
-// Squared distance
-       const Double_t pi=TMath::Pi();
-       Double_t dphi=TMath::Abs(x(1)-y(1));
-       if (dphi > pi) dphi=2*pi-dphi;
-       Double_t dist=pow(x(0)-y(0),2)+pow(dphi,2);
-       return dist;
+  // Squared distance
+  const Double_t pi=TMath::Pi();
+  Double_t dphi=TMath::Abs(x(1)-y(1));
+  if (dphi > pi) dphi=2*pi-dphi;
+  Double_t dist=pow(x(0)-y(0),2)+pow(dphi,2);
+  return dist;
+
 }
index 4e5a0c6..b484e6b 100644 (file)
@@ -4,46 +4,53 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
+/* $Id$ */
+
 //---------------------------------------------------------------------
 //Jet finder based on Deterministic Annealing
 //Author: Davide Perrino (davide.perrino@ba.infn.it)
+//        magali.estienne@subatech.in2p3.fr &
+//        alexandre.shabetai@cern.ch (Modification of the input object (reader/finder splitting))
+// ** 2011
+// Modified accordingly to reader/finder splitting and new handling of neutral information
 //---------------------------------------------------------------------
 
-#include <AliJetFinder.h>
+#include "AliJetFinder.h"
+
 #include <TMatrixD.h>
 #include <TVectorD.h>
-class AliDAJetHeader;
 
 class AliDAJetFinder : public AliJetFinder
 {
-public:
-    AliDAJetFinder();
-    virtual  ~AliDAJetFinder();
+ public:
+  AliDAJetFinder();
+  virtual  ~AliDAJetFinder();
+
+  void     FindJets      ();
+
+ protected:
+  Double_t fAlpha;          // beta increment
+  Double_t fDelta;          // perturbation proportional to Delta
+  Double_t fAvDist;         // minimum distance to distinguish two clusters
+  Double_t fEps;            // convergence criterium below max number of loops
+  Double_t fEpsMax;         // convergence criterium above max number of loops
+  Int_t    fNloopMax;       // maximum number of loops at a fixed beta
+  Double_t fBeta;           // increasing multiplier of entropy
+  Int_t    fNclustMax;      // maximum number of clusters to find
+  Int_t    fNin;            // number of input data
+  Int_t    fNeff;           // total input data, including fakes
 
-    void FindJets      ();
  private:
-    void InitDetAnn    (Double_t &dEtSum, Double_t **xData, TVectorD *px, TVectorD *py, TMatrixD *pyx, TMatrixD *y);
-    void Annealing     (Int_t nk, Double_t **xData, TVectorD *vPx, TVectorD *vPy, TMatrixD *mPyx, TMatrixD *mY);
-    void NumCl         (Int_t &nc, Int_t &nk, TVectorD *vPy, TMatrixD *mPyx, TMatrixD *mY);
-    void ReduceClusters(Int_t **iSame, Int_t nc, Int_t &ncout, Int_t **cont, Int_t *nSameOut) const;
-    void DoubleClusters(Int_t nc, Int_t &nk,  TVectorD *vPy,  TMatrixD *mY) const;
-    void EndDetAnn     (Int_t &nk, Double_t **xData, Int_t *xx, Double_t etx, TVectorD *px, TVectorD *py, TMatrixD *pyx, TMatrixD *y);
-    void StoreJets     (Int_t nk, Double_t **xData, Int_t *xx, TMatrixD *mY);
-
-protected:
-    AliDAJetFinder(const AliDAJetFinder &jf);
-    AliDAJetFinder& operator=(const AliDAJetFinder &jf);
-    Double_t   fAlpha;                                 // beta increment
-    Double_t   fDelta;                                 // perturbation proportional to Delta
-    Double_t   fAvDist;                                        // minimum distance to distinguish two clusters
-    Double_t   fEps;                                   // convergence criterium below max number of loops
-    Double_t   fEpsMax;                                        // convergence criterium above max number of loops
-    Int_t      fNloopMax;                              // maximum number of loops at a fixed beta
-    Double_t   fBeta;                                  // increasing multiplier of entropy
-    Int_t      fNclustMax;                             // maximum number of clusters to find
-    Int_t      fNin;                                   // number of input data
-    Int_t      fNeff;                                  // total input data, including fakes
-
-    ClassDef(AliDAJetFinder,3)
+  void     InitDetAnn    (Double_t &dEtSum, Double_t **xData, TVectorD *px, TVectorD *py, TMatrixD *pyx, TMatrixD *y);
+  void     Annealing     (Int_t nk, Double_t **xData, const TVectorD *vPx, TVectorD *vPy, TMatrixD *mPyx, TMatrixD *mY);
+  void     NumCl         (Int_t &nc, Int_t &nk, TVectorD *vPy, TMatrixD *mPyx, TMatrixD *mY);
+  void     ReduceClusters(Int_t **iSame, Int_t nc, Int_t &ncout, Int_t **cont, Int_t *nSameOut) const;
+  void     DoubleClusters(Int_t nc, Int_t &nk, TVectorD *vPy, TMatrixD *mY) const;
+  void     EndDetAnn     (Int_t &nk, Double_t **xData, Int_t *xx, Double_t etx, const TVectorD *px, TVectorD *py, TMatrixD *pyx, TMatrixD *y);
+  void     StoreJets     (Int_t nk, Double_t **xData, const Int_t *xx, const TMatrixD *mY);
+
+  ClassDef(AliDAJetFinder,4) // DA Jet finder
+
 };
+
 #endif
index 187ecd2..bde89af 100644 (file)
 // Deterministic Annealing Jet header class
 // Stores parameters of DA jet algorithm
 // Author: Davide Perrino (davide.perrino@ba.infn.it, davide.perrino@cern.ch)
+// 2011:
+// Adding FiducialEta/PhiMin/Max setters/getters and variables to accommodate with reader/finder splitting 
 //----------------------------------------------------------------------------
 
 #include "AliDAJetHeader.h"
 
 ClassImp(AliDAJetHeader)
 
+///////////////////////////////////////////////////////////////////////
 
-//---------------------------------------------------------------------
 AliDAJetHeader::AliDAJetHeader():
-       AliJetHeader("AliDAJetHeader"),
-       fSelectJets(kTRUE),
-       fRadius(0.7),
-       fNclustMax(10),
-       fFixedCl(kFALSE),
-       fEtMin(10.),
-       fNeff(0),
-       fEtaEff(0.9)
+  AliJetHeader("AliDAJetHeader"),
+  fSelectJets(kTRUE),
+  fNclustMax(10),
+  fFixedCl(kFALSE),
+  fEtMin(10.),
+  fNeff(0),
+  fEtaEff(0.9),
+  fFidEtaMin(-0.9),
+  fFidEtaMax(0.9),
+  fFidPhiMin(0.),
+  fFidPhiMax(2*TMath::Pi())
 {
-    // Constructor
+  // Constructor
 }
 
 //---------------------------------------------------------------------
 void AliDAJetHeader::SetRadius(Float_t radius)
 {
-    // The radius requested is used to estimate the number of clusters
-    // to be found, in order to obtain jets with the expected area.
-    // It must not be intended as a sharp limit on the cluster radius
+  // The radius requested is used to estimate the number of clusters
+  // to be found, in order to obtain jets with the expected area.
+  // It must not be intended as a sharp limit on the cluster radius
     
   Int_t nclust = (Int_t) (4.*fEtaEff/(radius*radius)) + 1;
   SetNclust(nclust);
+
 }
index 7a70921..c8cfca0 100644 (file)
@@ -8,44 +8,55 @@
 // Jet header class for Deterministic Annealing
 // Stores the parameters of the DA jet algorithm
 // Author: Davide Perrino (davide.perrino@ba.infn.it)
+// 2011:
+// Adding FiducialEta/PhiMin/Max setters/getters and variables to accommodate with reader/finder splitting
 //---------------------------------------------------------------------
 
-#include <AliJetHeader.h>
+#include "AliJetHeader.h"
 
 class AliDAJetHeader : public AliJetHeader
 {
-  public:
-
-       AliDAJetHeader();
-       virtual ~AliDAJetHeader() {}
-
-       void SelectJets         (Bool_t seljets ) { fSelectJets=seljets; }
-       void SetRadius          (Float_t radius );
-       void SetNclust          (Int_t ncl      ) { fNclustMax=ncl ; fFixedCl=kTRUE; }
-       void SetEtMin           (Float_t etmin  ) { fEtMin =etmin;  }
-       void SetNeff            (Int_t n        ) { fNeff = n; }
-       void SetEtaEff          (Float_t eta    ) { fEtaEff = eta;  }
-
-       Bool_t   GetSelJets()   const { return fSelectJets; }
-       Float_t  GetRadius()    const { return fRadius;    }
-       Int_t    GetNclustMax() const { return fNclustMax; }
-       Bool_t   GetFixedCl()   const { return fFixedCl; }
-       Float_t  GetEtMin()             const { return fEtMin;   }
-       Int_t    GetNeff()              const { return fNeff;    }
-       Float_t  GetEtaEff()    const { return fEtaEff;  }
-
-  protected:
-       AliDAJetHeader(const AliDAJetHeader &jh);
-       AliDAJetHeader& operator=(const AliDAJetHeader &jh);
-       Bool_t          fSelectJets;                                    // select jets among clusters
-    Float_t    fRadius;                                                // jet "radius"
-       Int_t           fNclustMax;                                             // number of clusters when to stop annealing
-       Bool_t          fFixedCl;                                               // use a fixed fNclustMax
-       Float_t         fEtMin;                                                 // minimum energy for found jets
-       Int_t           fNeff;                                                  // number of total input data, including fakes
-       Float_t         fEtaEff;                                                // eta range in which fake tracks are generated
-
-       ClassDef(AliDAJetHeader,3)
+ public:
+  AliDAJetHeader();
+  virtual ~AliDAJetHeader() {}
+
+  void    SelectJets        (Bool_t seljets) { fSelectJets=seljets; }
+  void    SetRadius        (Float_t radius);
+  void    SetNclust        (Int_t ncl     ) { fNclustMax=ncl ; fFixedCl=kTRUE; }
+  void    SetEtMin         (Float_t etmin ) { fEtMin =etmin; }
+  void    SetNeff          (Int_t n       ) { fNeff = n; }
+  void    SetEtaEff        (Float_t eta   ) { fEtaEff = eta; }
+  void    SetFiducialEtaMin (Float_t etamin) { fFidEtaMin = etamin; }
+  void    SetFiducialEtaMax (Float_t etamax) { fFidEtaMax = etamax; }
+  void    SetFiducialPhiMin (Float_t phimin) { fFidPhiMin = phimin; }
+  void    SetFiducialPhiMax (Float_t phimax) { fFidPhiMax = phimax; }
+
+  Bool_t  GetSelJets() const                 { return fSelectJets; }
+  Float_t GetRadius() const                  { return fRadius; }
+  Int_t   GetNclustMax() const               { return fNclustMax; }
+  Bool_t  GetFixedCl() const                 { return fFixedCl; }
+  Float_t GetEtMin() const                   { return fEtMin; }
+  Int_t   GetNeff() const                    { return fNeff; }
+  Float_t GetEtaEff() const                  { return fEtaEff; }
+  Float_t GetFiducialEtaMin() const          { return fFidEtaMin; }
+  Float_t GetFiducialEtaMax() const          { return fFidEtaMax; }
+  Float_t GetFiducialPhiMin() const          { return fFidPhiMin; }
+  Float_t GetFiducialPhiMax() const          { return fFidPhiMax; }
+
+ protected:
+  Bool_t  fSelectJets;      // select jets among clusters
+  Int_t          fNclustMax;        // number of clusters when to stop annealing
+  Bool_t  fFixedCl;         // use a fixed fNclustMax
+  Float_t fEtMin;           // minimum energy for found jets
+  Int_t          fNeff;             // number of total input data, including fakes
+  Float_t fEtaEff;          // eta range in which fake tracks are generated
+  Float_t fFidEtaMin;        // fiducial eta min for particles
+  Float_t fFidEtaMax;        // fiducial eta max for particles
+  Float_t fFidPhiMin;        // fiducial phi min for paticles
+  Float_t fFidPhiMax;        // fiducial phi max for paticles
+
+  ClassDef(AliDAJetHeader,4) // DA jet header class
+
 };
 
 #endif
index f15989b..ddce477 100644 (file)
@@ -13,6 +13,7 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
  
+/* $Id$ */
 
 //---------------------------------------------------------------------
 // FastJet v2.3.4 finder algorithm interface
 // Authors: Rafael.Diaz.Valdes@cern.ch
 //          Magali.estienne@subatech.in2p3.fr (neutral part + bg subtraction option)
 //
+// ** 2011 magali.estienne@subatech.in2p3.fr &  alexandre.shabetai@cern.ch
+// new implementation of background subtraction
+// allowing to subtract bkg using a different algo than the one used for signal jets
 //---------------------------------------------------------------------
 
-
 #include <Riostream.h>
-#include <TLorentzVector.h>
-#include <TFile.h>
-#include <TH1F.h>
-#include <TH2F.h>
-#include <TArrayF.h>
-#include <TClonesArray.h>
 
 #include "AliFastJetFinder.h"
 #include "AliFastJetHeaderV1.h"
-#include "AliJetReaderHeader.h"
-#include "AliJetReader.h"
-#include "AliJetUnitArray.h"
 #include "AliFastJetInput.h"
-#include "AliJetBkg.h"
+#include "AliFastJetBkg.h"
 #include "AliAODJetEventBackground.h"
-#include "AliAODTrack.h"
+#include "AliAODJet.h"
 
 #include "fastjet/PseudoJet.hh"
 #include "fastjet/ClusterSequenceArea.hh"
 #include "fastjet/AreaDefinition.hh"
 #include "fastjet/JetDefinition.hh"
-// get info on how fastjet was configured
-#include "fastjet/config.h"
-
-#ifdef ENABLE_PLUGIN_SISCONE
-#include "fastjet/SISConePlugin.hh"
-#endif
 
-#include<sstream>  // needed for internal io
 #include<vector> 
-#include <cmath> 
 
 using namespace std;
 
-
 ClassImp(AliFastJetFinder)
 
-
-//____________________________________________________________________________
+////////////////////////////////////////////////////////////////////////
 
 AliFastJetFinder::AliFastJetFinder():
   AliJetFinder(),
   fInputFJ(new AliFastJetInput()),
-  fJetBkg(new  AliJetBkg())
+  fJetBkg(new  AliFastJetBkg())
 {
   // Constructor
 }
 
 //____________________________________________________________________________
-
 AliFastJetFinder::~AliFastJetFinder()
 {
   // destructor
-  delete  fInputFJ; fInputFJ = 0;
-  delete  fJetBkg; fJetBkg = 0;
+  delete  fInputFJ;
+  delete  fJetBkg;
+
 }
 
 //______________________________________________________________________________
 void AliFastJetFinder::FindJets()
 {
+  // runs a FASTJET based algo
 
   //pick up fastjet header
   AliFastJetHeaderV1 *header = (AliFastJetHeaderV1*)fHeader;
   Int_t  debug  = header->GetDebug();     // debug option
   Bool_t bgMode = header->GetBGMode();    // choose to subtract BG or not
-  if(debug)cout<<"----------in AliFastJetFinder::FindJets() ------------------"<<endl;
-
-  // check if we are reading AOD jets
-  TRefArray *refs = 0;
-  Bool_t fromAod = !strcmp(fReader->ClassName(),"AliJetAODReader");
-  if (fromAod) { refs = fReader->GetReferences(); }
+  if(debug>0) cout<<"----------in AliFastJetFinder::FindJets() ------------------"<<endl;
 
   // RUN ALGORITHM  
   // read input particles -----------------------------
 
   vector<fastjet::PseudoJet> inputParticles=fInputFJ->GetInputParticles();
   if(inputParticles.size()==0){
-    if(debug)Printf("%s:%d No input particles found, skipping event",(char*)__FILE__,__LINE__);
+    if(debug>0) Printf("%s:%d No input particles found, skipping event",(char*)__FILE__,__LINE__);
     return;
   }
 
@@ -117,8 +97,8 @@ void AliFastJetFinder::FindJets()
 
   // create an object that specifies how we to define the area
   fastjet::AreaDefinition areaDef;
-  double ghostEtamax = header->GetGhostEtaMax(); 
-  double ghostArea   = header->GetGhostArea(); 
+  double ghostEtamax       = header->GetGhostEtaMax(); 
+  double ghostArea         = header->GetGhostArea(); 
   int    activeAreaRepeats = header->GetActiveAreaRepeats(); 
   
   // now create the object that holds info about ghosts
@@ -135,10 +115,10 @@ void AliFastJetFinder::FindJets()
 
   if(bgMode) // Do BG subtraction directly with the same algorithm (cambridge or kt) for jet signal and background
     {
-      //***************************** CLUSTER JETS FINDING FOR RHO ESTIMATION
+      //***************************** JETS FINDING FOR RHO ESTIMATION
       // run the jet clustering with the above jet definition
-         fastjet::JetAlgorithm algorithmBkg = header->GetBGAlgorithm();
-         fastjet::JetDefinition jetDefBkg(algorithmBkg, rBkgParam, recombScheme, strategy);
+      fastjet::JetAlgorithm algorithmBkg = header->GetBGAlgorithm();
+      fastjet::JetDefinition jetDefBkg(algorithmBkg, rBkgParam, recombScheme, strategy);
       fastjet::ClusterSequenceArea clust_seq_bkg(inputParticles, jetDefBkg, areaDef);
 
       // save a comment in the header
@@ -149,20 +129,19 @@ void AliFastJetFinder::FindJets()
       comment+= TString(jetDefBkg.description());
       comment+= ". Area definition: ";
       comment+= TString(areaDef.description());
-      comment+= ". Strategy adopted by FastJet and bkg: ";
+      comment+= ". Strategy adopted by FastJet: ";
       comment+= TString(clust_seq.strategy_string());
       header->SetComment(comment);
-      if(debug){
-          cout << "--------------------------------------------------------" << endl;
-          cout << comment << endl;
-          cout << "--------------------------------------------------------" << endl;
+      if(debug>0){
+       cout << "--------------------------------------------------------" << endl;
+       cout << comment << endl;
+       cout << "--------------------------------------------------------" << endl;
       }
-      //header->PrintParameters();
       
-      // extract the inclusive jets with pt > ptmin, sorted by pt
+      // extract the inclusive jets sorted by pt
       double ptmin = header->GetPtMin(); 
       vector<fastjet::PseudoJet> inclusiveJets = clust_seq.inclusive_jets();
-
+      
       //subtract background // ===========================================
       // set the rapididty , phi range within which to study the background 
       double rapMax = header->GetRapMax(); 
@@ -170,139 +149,98 @@ void AliFastJetFinder::FindJets()
       double phiMax = header->GetPhiMax();
       double phiMin = header->GetPhiMin();
       fastjet::RangeDefinition range(rapMin, rapMax, phiMin, phiMax);
-      
+     
       // Extract rho and sigma
       Double_t rho = 0.;
       Double_t sigma = 0.;
       Double_t meanarea = 0.;
-      Bool_t Use4VectorArea = header->Use4VectorArea();
+      Bool_t kUse4VectorArea = header->Use4VectorArea();
       vector<fastjet::PseudoJet> bkgJets = clust_seq_bkg.inclusive_jets();
-      clust_seq_bkg.get_median_rho_and_sigma(bkgJets,range, Use4VectorArea, rho, sigma, meanarea, false);
+      clust_seq_bkg.get_median_rho_and_sigma(bkgJets,range, kUse4VectorArea, rho, sigma, meanarea, false);
 
-         // subtract background and extract jets bkg subtracted
+      // subtract background and extract jets bkg subtracted
       vector<fastjet::PseudoJet> subJets = clust_seq.subtracted_jets(rho,ptmin);
-
-         // print out
-      //cout << "Printing inclusive sub jets with pt > "<< ptmin<<" GeV\n";
-      //cout << "---------------------------------------\n";
-      //cout << endl;
-      //printf(" ijet   rap      phi        Pt         area  +-   err\n");
       
       // sort jets into increasing pt
       jets = sorted_by_pt(subJets);  
 
     }
-  else { // No BG subtraction!!!!!!!! Default header is bgmode=0.
-
-         // save a comment in the header
-         TString comment = "Running FastJet algorithm with the following setup. ";
-         comment+= "Jet definition: ";
-         comment+= TString(jetDef.description());
-         comment+= ". Strategy adopted by FastJet: ";
-         comment+= TString(clust_seq.strategy_string());
-         header->SetComment(comment);
-         if(debug){
-                 cout << "--------------------------------------------------------" << endl;
-                 cout << comment << endl;
-                 cout << "--------------------------------------------------------" << endl;
-         }
-         //header->PrintParameters();
-
-         // extract the inclusive jets with pt > ptmin, sorted by pt
-         double ptmin = header->GetPtMin();
-         vector<fastjet::PseudoJet> inclusiveJets = clust_seq.inclusive_jets(ptmin);
-
-         jets = sorted_by_pt(inclusiveJets); // Added by me
 
+  else { // No BG subtraction!!!!!!!! Default header is bgmode=0.
+    
+    // save a comment in the header
+    TString comment = "Running FastJet algorithm with the following setup. ";
+    comment+= "Jet definition: ";
+    comment+= TString(jetDef.description());
+    comment+= ". Strategy adopted by FastJet: ";
+    comment+= TString(clust_seq.strategy_string());
+    header->SetComment(comment);
+    if(debug>0){
+      cout << "--------------------------------------------------------" << endl;
+      cout << comment << endl;
+      cout << "--------------------------------------------------------" << endl;
+    }
+  
+    // extract the inclusive jets with pt > ptmin, sorted by pt
+    double ptmin = header->GetPtMin(); 
+    vector<fastjet::PseudoJet> inclusiveJets = clust_seq.inclusive_jets(ptmin);
+    
+    jets = sorted_by_pt(inclusiveJets); 
+  
   }
+   
+  for (size_t j = 0; j < jets.size(); j++) { // loop for jets     
 
-  for (size_t j = 0; j < jets.size(); j++) { // loop for jets
-
-         double area      = clust_seq.area(jets[j]);
-         double areaError = clust_seq.area_error(jets[j]);
+    double area      = clust_seq.area(jets[j]);
+    double areaError = clust_seq.area_error(jets[j]);
 
-         if(debug) printf("Jet found %5d %9.5f %8.5f %10.3f %8.3f +- %6.3f\n", (Int_t)j,jets[j].rap(),jets[j].phi(),jets[j].perp(), area, areaError);
+    if(debug>0) printf("Jet found %5d %9.5f %8.5f %10.3f \n",(Int_t)j,jets[j].rap(),jets[j].phi(),jets[j].perp());
 
-      vector<fastjet::PseudoJet> constituents = clust_seq.constituents(jets[j]);
-      int nCon= constituents.size();
-      TArrayI ind(nCon);
+    vector<fastjet::PseudoJet> constituents = clust_seq.constituents(jets[j]);
+    int nCon= constituents.size();
+    TArrayI ind(nCon);
+      
+    if ((jets[j].eta() > (header->GetJetEtaMax())) ||
+       (jets[j].eta() < (header->GetJetEtaMin())) ||
+       (jets[j].phi() > (header->GetJetPhiMax())) ||
+       (jets[j].phi() < (header->GetJetPhiMin())) ||
+       (jets[j].perp() < header->GetPtMin())) continue; // acceptance eta range and etmin
+
+    // go to write AOD  info
+    AliAODJet aodjet (jets[j].px(), jets[j].py(), jets[j].pz(), jets[j].E());
+    aodjet.SetEffArea(area,areaError);
+    //cout << "Printing jet " << endl;
+    if(debug>0) aodjet.Print("");
       
-      if ((jets[j].eta() > (header->GetJetEtaMax())) ||
-          (jets[j].eta() < (header->GetJetEtaMin())) ||
-          (jets[j].phi() > (header->GetJetPhiMax())) ||
-          (jets[j].phi() < (header->GetJetPhiMin())) ||
-          (jets[j].perp() < header->GetPtMin())) continue; // acceptance eta range and etmin
-
-         // go to write AOD  info
-         AliAODJet aodjet (jets[j].px(), jets[j].py(), jets[j].pz(), jets[j].E());
-      aodjet.SetEffArea(area,areaError);
-         //cout << "Printing jet " << endl;
-         if(debug) aodjet.Print("");
-
-         Int_t count=0;
-         for (int i=0; i < nCon; i++)
+    for (int i=0; i < nCon; i++)
+      {
+       fastjet::PseudoJet mPart=constituents[i];
+       ind[i]=mPart.user_index();
+
+       // Jet constituents (charged tracks) added to the AliAODJet
+       AliJetCalTrkEvent* calEvt  = GetCalTrkEvent();
+       for(Int_t itrack=0; itrack<calEvt->GetNCalTrkTracks(); itrack++)
          {
-                 fastjet::PseudoJet mPart=constituents[i];
-                 ind[i]=mPart.user_index();
-                 //    cout<<i<<"  index="<<ind[i]<<endl;
-
-                 if(fromAod)
-                 {
-                         if(fReader->GetReaderHeader()->GetDetector()==0)
-                         {
-                                 for (Int_t iref = 0; iref < refs->GetEntries(); iref++)
-                                 {
-                                         if(iref==ind[i]){
-                                                 AliAODTrack * track = (AliAODTrack*)refs->At(iref);
-                                                 aodjet.AddTrack(track);
-                                         }
-                                 }
-
-                         } else {
-
-                                 TClonesArray* fUnit = fReader->GetUnitArray(); //Big mmentum array
-                                 if(fUnit == 0) { cout << "Could not get the momentum array" << endl; return; }
-                                 Int_t         nIn = fUnit->GetEntries();
-
-                                 //internal loop over all the unit cells
-                                 Int_t ipart = 0;
-
-                                 for(Int_t ii=0; ii<nIn; ii++)
-                                 {
-                                         AliJetUnitArray *uArray = (AliJetUnitArray*)fUnit->At(ii);
-                                         if(uArray->GetUnitEnergy()>0.){
-                                                 uArray->SetUnitTrackID(ipart);//used to have the index available in AliJEtBkg
-                                                 if(ipart==ind[i]){
-                                                         TRefArray* trackArray = (TRefArray*)uArray->GetUnitTrackRef();
-                                                         Int_t tracksInCell = trackArray->GetEntries();
-                                                         for(int ji = 0; ji < tracksInCell; ji++){
-                                                                 AliAODTrack * track = (AliAODTrack*)trackArray->At(ji);
-                                                                 aodjet.AddTrack(track);
-                                                         }
-
-                                                         count++;
-                                                 }
-                                                 ipart++;
-                                         }
-                                 }
-                         }
-                 }
-        } 
-
- AddJet(aodjet);
-
-
-  } // End loop on jets
+           if(itrack==ind[i])
+             {
+               TObject *track = calEvt->GetCalTrkTrack(itrack)->GetTrackObject();
+               aodjet.AddTrack(track);
+             }
+         }
+      } // End loop on Constituents
+
+    AddJet(aodjet);
+           
+  } // end loop for jets
 
 }
 
 //____________________________________________________________________________
 void AliFastJetFinder::RunTest(const char* datafile)
-
 {
+  // This simple test run the kt algorithm for an ascii file testdata.dat
 
-   // This simple test run the kt algorithm for an ascii file testdata.dat
-   // read input particles -----------------------------
+  // read input particles -----------------------------
   vector<fastjet::PseudoJet> inputParticles;
   Float_t px,py,pz,en;
   ifstream in;
@@ -311,15 +249,15 @@ void AliFastJetFinder::RunTest(const char* datafile)
   // this file has 3 columns of float data
   in.open(datafile);
   while (1) {
-      in >> px >> py >> pz >> en;
-      if (!in.good()) break;
-      //printf("px=%8f, py=%8f, pz=%8fn",px,py,pz);
-      nlines++;
-      inputParticles.push_back(fastjet::PseudoJet(px,py,pz,en)); 
-   }
-   //printf(" found %d pointsn",nlines);
-   in.close();
-   //////////////////////////////////////////////////
+    in >> px >> py >> pz >> en;
+    if (!in.good()) break;
+    //printf("px=%8f, py=%8f, pz=%8fn",px,py,pz);
+    nlines++;
+    inputParticles.push_back(fastjet::PseudoJet(px,py,pz,en)); 
+  }
+  //printf(" found %d pointsn",nlines);
+  in.close();
+  //////////////////////////////////////////////////
  
   // create an object that represents your choice of jet algorithm, and 
   // the associated parameters
@@ -328,32 +266,26 @@ void AliFastJetFinder::RunTest(const char* datafile)
   fastjet::RecombinationScheme recombScheme = fastjet::BIpt_scheme;
   fastjet::JetDefinition jetDef(fastjet::kt_algorithm, rParam, recombScheme, strategy);
   
-  
   // create an object that specifies how we to define the area
   fastjet::AreaDefinition areaDef;
   double ghostEtamax = 7.0;
   double ghostArea    = 0.05;
   int    activeAreaRepeats = 1;
   
-
   // now create the object that holds info about ghosts
   fastjet::GhostedAreaSpec ghostSpec(ghostEtamax, activeAreaRepeats, ghostArea);
   // and from that get an area definition
   areaDef = fastjet::AreaDefinition(fastjet::active_area,ghostSpec);
-  
 
   // run the jet clustering with the above jet definition
   fastjet::ClusterSequenceArea clust_seq(inputParticles, jetDef, areaDef);
   
-  
   // tell the user what was done
   cout << "--------------------------------------------------------" << endl;
   cout << "Jet definition was: " << jetDef.description() << endl;
   cout << "Area definition was: " << areaDef.description() << endl;
   cout << "Strategy adopted by FastJet was "<< clust_seq.strategy_string()<<endl<<endl;
   cout << "--------------------------------------------------------" << endl;
   
   // extract the inclusive jets with pt > 5 GeV, sorted by pt
   double ptmin = 5.0;
@@ -361,7 +293,6 @@ void AliFastJetFinder::RunTest(const char* datafile)
   
   cout << "Number of unclustered particles: " << clust_seq.unclustered_particles().size() << endl;
  
   //subtract background // ===========================================
   // set the rapididty range within which to study the background 
   double rapMax = ghostEtamax - rParam;
@@ -377,168 +308,62 @@ void AliFastJetFinder::RunTest(const char* datafile)
 
   printf(" ijet   rap      phi        Pt         area  +-   err\n");
   for (size_t j = 0; j < jets.size(); j++) {
-
-    double area     = clust_seq.area(jets[j]);
+    double area      = clust_seq.area(jets[j]);
     double areaError = clust_seq.area_error(jets[j]);
-
     printf("%5d %9.5f %8.5f %10.3f %8.3f +- %6.3f\n",(Int_t)j,jets[j].rap(),
           jets[j].phi(),jets[j].perp(), area, areaError);
   }
   cout << endl;
   // ================================================================
 
-  
 }
 
 //____________________________________________________________________________
-
 void AliFastJetFinder::WriteJHeaderToFile() const
 {
+  // Write Jet Header to file
   fHeader->Write();
-}
-
-//____________________________________________________________________________
-
-Float_t  AliFastJetFinder::EtaToTheta(Float_t arg)
-{
-  //  return (180./TMath::Pi())*2.*atan(exp(-arg));
-  return 2.*atan(exp(-arg));
-
 
 }
 
 //____________________________________________________________________________
-
-void AliFastJetFinder::InitTask(TChain *tree)
-{
-
-  printf("Fast jet finder initialization ******************");
-  fReader->CreateTasks(tree);
-
-}
-
-
 Bool_t AliFastJetFinder::ProcessEvent()
 {
-  //
   // Process one event
-  // from meomntum array
-
-  Bool_t ok = fReader->FillMomentumArray();
+  // Charged only or charged+neutral jets
 
-  if (!ok) return kFALSE;
   fInputFJ->SetHeader(fHeader);
-  fInputFJ->SetReader(fReader);
+  fInputFJ->SetCalTrkEvent(GetCalTrkEvent());
   fInputFJ->FillInput();
-  // Jets
+  
+  // Find Jets
   FindJets(); 
 
+  // Background
+  if(fAODEvBkg){
+    AliFastJetHeaderV1 *header = (AliFastJetHeaderV1*)fHeader;
 
-  if( fAODEvBkg){
     fJetBkg->SetHeader(fHeader);
-    fJetBkg->SetReader(fReader);
-    Double_t sigma1 = 0,meanarea1= 0,sigma2 = 0,meanarea2 = 0;
-    Double_t bkg1 = 0,bkg2 = 0;
-    
     fJetBkg->SetFastJetInput(fInputFJ);
-    fJetBkg->BkgFastJetb(bkg1,sigma1,meanarea1);
-    fJetBkg->BkgFastJetWoHardest(bkg2,sigma2,meanarea2);
-    fAODEvBkg->SetBackground(0,bkg1,sigma1,meanarea1);
-    fAODEvBkg->SetBackground(1,bkg2,sigma2,meanarea2);
-  }
-
-
-
+    
+     Int_t count = 0;  
+     if(header->GetBkgFastJetb()){
+        Double_t sigma1 = 0 , meanarea1= 0, bkg1 = 0;
+        fJetBkg->BkgFastJetb(bkg1,sigma1,meanarea1);
+        fAODEvBkg->SetBackground(count,bkg1,sigma1,meanarea1);
+        count++;
+     }
+
+     if(header->GetBkgFastJetWoHardest()){
+        Double_t sigma2 = 0 , meanarea2 = 0, bkg2 = 0;
+        fJetBkg->BkgFastJetWoHardest(bkg2,sigma2,meanarea2);
+        fAODEvBkg->SetBackground(count,bkg2,sigma2,meanarea2);
+        count++;
+     }
+
+  }  
 
-  /*
-  fJetBkg->SetFastJetInput(fInputFJ);
-  Double_t bkg1=fJetBkg->BkgFastJet();
-  Double_t bkg2=fJetBkg->BkgChargedFastJet();
-  Double_t bkg3=fJetBkg->BkgFastJetCone(fAODjets);
-  Double_t bkg4=fJetBkg->BkgRemoveJetLeading(fAODjets);
-  
-  fAODEvBkg->SetBackground(0,bkg1);
-  fAODEvBkg->SetBackground(1,bkg2);
-  fAODEvBkg->SetBackground(2,bkg3);
-  fAODEvBkg->SetBackground(3,bkg4);
-  */
   Reset();  
   return kTRUE;
 
 }
-
-Bool_t AliFastJetFinder::ProcessEvent2()
-{
-  //
-  // Process one event
-  // Charged only or charged+neutral jets
-  //
-
-  TRefArray* ref = new TRefArray();
-  Bool_t procid = kFALSE;
-  Bool_t ok = fReader->ExecTasks(procid,ref);
-
-  // Delete reference pointer  
-  if (!ok) {delete ref; return kFALSE;}
-  
-  // Leading particles
-  fInputFJ->SetHeader(fHeader);
-  fInputFJ->SetReader(fReader);
-  fInputFJ->FillInput();
-  
-  // Jets
-  FindJets();
-  
-  if( fAODEvBkg){
-    fJetBkg->SetHeader(fHeader);
-    fJetBkg->SetReader(fReader);
-    fJetBkg->SetFastJetInput(fInputFJ);
-    Double_t sigma1,meanarea1,sigma2,meanarea2;
-    Double_t bkg1,bkg2;
-    fJetBkg->BkgFastJetb(bkg1,sigma1,meanarea1);
-    fJetBkg->BkgFastJetWoHardest(bkg2,sigma2,meanarea2);
-    fAODEvBkg->SetBackground(0,bkg1,sigma1,meanarea1);
-    fAODEvBkg->SetBackground(1,bkg2,sigma2,meanarea2);
-  }
-
-
-//  Double_t bkg1=fJetBkg->BkgFastJet();
-//  Double_t bkg2=fJetBkg->BkgChargedFastJet();
-//  Double_t bkg3=fJetBkg->BkgFastJetCone(fAODjets);
-//  Double_t bkg4=fJetBkg->BkgRemoveJetLeading(fAODjets);
-  
-//  fAODEvBkg->SetBackground(0,bkg1);
-//  fAODEvBkg->SetBackground(1,bkg2);
-//  fAODEvBkg->SetBackground(2,bkg3);
-//  fAODEvBkg->SetBackground(3,bkg4);
-  
-  Int_t nEntRef    = ref->GetEntries();
-
-  for(Int_t i=0; i<nEntRef; i++)
-    { 
-      // Reset the UnitArray content which were referenced
-      ((AliJetUnitArray*)ref->At(i))->SetUnitTrackID(0);
-      ((AliJetUnitArray*)ref->At(i))->SetUnitEnergy(0.);
-      ((AliJetUnitArray*)ref->At(i))->SetUnitCutFlag(kPtSmaller);
-      ((AliJetUnitArray*)ref->At(i))->SetUnitCutFlag2(kPtSmaller);
-      ((AliJetUnitArray*)ref->At(i))->SetUnitSignalFlag(kBad);
-      ((AliJetUnitArray*)ref->At(i))->SetUnitSignalFlagC(kTRUE,kBad);
-      ((AliJetUnitArray*)ref->At(i))->SetUnitDetectorFlag(kTpc);
-      ((AliJetUnitArray*)ref->At(i))->SetUnitFlag(kOutJet);
-      ((AliJetUnitArray*)ref->At(i))->ClearUnitTrackRef();
-
-      // Reset process ID
-      AliJetUnitArray* uA = (AliJetUnitArray*)ref->At(i);
-      uA->ResetBit(kIsReferenced);
-      uA->SetUniqueID(0);     
-    }
-
-  // Delete the reference pointer
-  ref->Delete();
-  delete ref;
-
-  Reset();
-
-  return kTRUE;
-}
index 71a7b34..9835091 100644 (file)
@@ -4,46 +4,39 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-
+/* $Id$ */
 
 //---------------------------------------------------------------------
 // FastJet v2.3.4 finder algorithm interface
 //
 // Author: Rafael.Diaz.Valdes@cern.ch
-//  
+//
+// ** 2011 magali.estienne@subatech.in2p3.fr &  alexandre.shabetai@cern.ch
+// new implementation of background subtraction
+// allowing to subtract bkg using a different algo than the one used for signal jets  
 //---------------------------------------------------------------------
 
-//FastJet classes 
+// FastJet classes 
 #ifndef __CINT__
 # include "fastjet/PseudoJet.hh"
 # include "fastjet/ClusterSequenceArea.hh"
 # include "fastjet/AreaDefinition.hh"
 # include "fastjet/JetDefinition.hh"
-// get info on how fastjet was configured
-# include "fastjet/config.h"
-# ifdef ENABLE_PLUGIN_SISCONE
-#  include "fastjet/SISConePlugin.hh"
-# endif
 #else
 namespace fastjet {
-class PseudoJet;
-class ClusterSequenceArea;
-class AreaDefinition;
-class JetDefinition;
+  class PseudoJet;
+  class ClusterSequenceArea;
+  class AreaDefinition;
+  class JetDefinition;
 }
 #endif
 
-
-#include<sstream>  // needed for internal io
-#include <vector> 
-#include <cmath> 
-
 #include "AliJetFinder.h"
-#include "AliFastJetHeaderV1.h"
 
-using namespace std;
 class AliFastJetInput;
-class AliJetBkg;
+class AliFastJetBkg;
+
+using namespace std;
 
 class AliFastJetFinder : public AliJetFinder
 {
@@ -52,21 +45,19 @@ class AliFastJetFinder : public AliJetFinder
   AliFastJetFinder();
   ~AliFastJetFinder();
 
-  virtual void    FindJets(); 
-  void    RunTest(const char* datafile); // a simple test
-  virtual void    WriteJHeaderToFile() const;
-  Float_t EtaToTheta(Float_t arg);
-  void    InitTask(TChain* tree);
-  virtual Bool_t ProcessEvent();
-  virtual Bool_t  ProcessEvent2();
-  
+  virtual void      FindJets(); 
+  void              RunTest(const char* datafile); // a simple test
+  virtual void      WriteJHeaderToFile() const;
+  virtual Bool_t    ProcessEvent();
       
   protected:
   AliFastJetFinder(const AliFastJetFinder& rfj);
   AliFastJetFinder& operator = (const AliFastJetFinder& rsfj);
-  AliFastJetInput*                fInputFJ;     //! input particles array
-  AliJetBkg*                      fJetBkg;      //! pointer to bkg class
-  ClassDef(AliFastJetFinder,2)
+  AliFastJetInput*  fInputFJ;  //! input particles array
+  AliFastJetBkg*    fJetBkg;   //! pointer to bkg class
+
+  ClassDef(AliFastJetFinder,3) //  Fastjet analysis class
+
 };
 
 #endif
diff --git a/JETAN/AliFastJetHeader.cxx b/JETAN/AliFastJetHeader.cxx
deleted file mode 100644 (file)
index dcc888e..0000000
+++ /dev/null
@@ -1,89 +0,0 @@
-/**************************************************************************
- * 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.                  *
- **************************************************************************/
-
-
-//---------------------------------------------------------------------
-// FastJet v2.3.4 finder algorithm interface
-// Finder Header Class 
-// Author: Rafael.Diaz.Valdes@cern.ch
-//---------------------------------------------------------------------
-
-#include <Riostream.h>
-#include <TMath.h>
-
-#include "fastjet/ClusterSequenceArea.hh"
-#include "fastjet/AreaDefinition.hh"
-#include "fastjet/JetDefinition.hh"
-
-#include "AliFastJetHeader.h"
-
-ClassImp(AliFastJetHeader)
-
-////////////////////////////////////////////////////////////////////////
-
-AliFastJetHeader::AliFastJetHeader():
-    AliJetHeader("AliFastJetHeader"),
-    fRparam(1.0), 
-    fAlgorithm(fastjet::kt_algorithm),
-    fStrategy(fastjet::Best),
-    fRecombScheme(fastjet::BIpt_scheme),
-    fGhostEtaMax(2.0),
-    fGhostArea(0.05),
-    fActiveAreaRepeats(1),
-    fAreaType(fastjet::active_area), 
-    fPtMin(5.0),
-    fRapMax(0),
-    fRapMin(0),
-    fPhiMax(TMath::TwoPi()),
-    fPhiMin(0)
-{
-  // Constructor
-  
-  Double_t rapmax = fGhostEtaMax - fRparam;
-  Double_t rapmin = -fGhostEtaMax + fRparam;
-  SetRapRange(rapmin, rapmax);
-  
-}
-
-////////////////////////////////////////////////////////////////////////
-
-void AliFastJetHeader::PrintParameters() const
-{
-  // prints out parameters of jet algorithm
-
-  cout << "FastJet algorithm  parameters:" << endl;
-  
-  cout << "-- Jet Definition --- " << endl;
-  cout << "R " << fRparam << endl;
-  cout << "Jet Algorithm " << fAlgorithm << endl; 
-  cout << "Strategy " << fStrategy << endl;  
-  cout << "Recombination Scheme " << fRecombScheme << endl; 
-  
-  cout << "-- Ghosted Area Spec parameters --- " << endl;
-  cout << "Ghost Eta Max " << fGhostEtaMax << endl;
-  cout << "Ghost Area " << fGhostArea << endl;
-  cout << "Active Area Repeats " << fActiveAreaRepeats << endl;
-  
-  cout << "-- Area Definition parameters --- " << endl;
-  cout << "Area Type " << fAreaType << endl; 
-  
-  cout << "-- Cluster Sequence Area parameters --- " << endl;
-  cout << "pt min " << fPtMin << endl; 
-  
-  cout << "-- Range Definition parameters --- " << endl;
-  cout << " bkg rapidity range from  " << fRapMin << " to " << fRapMax << endl;
-  cout << " bkg phi range from " << fPhiMin << " to " << fPhiMax << endl;
-
-}
diff --git a/JETAN/AliFastJetHeader.h b/JETAN/AliFastJetHeader.h
deleted file mode 100644 (file)
index dca4866..0000000
+++ /dev/null
@@ -1,97 +0,0 @@
-#ifndef ALIFASTJETHEADER_H
-#define ALIFASTJETHEADER_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-//---------------------------------------------------------------------
-// FastJet v2.3.4 finder algorithm interface
-// Finder Header Class 
-// Author: Rafael.Diaz.Valdes@cern.ch
-//---------------------------------------------------------------------
-
-#ifndef __CINT__
-# include "fastjet/ClusterSequenceArea.hh"
-# include "fastjet/AreaDefinition.hh"
-# include "fastjet/JetDefinition.hh"
-#else
-namespace fastjet {
-  enum JetAlgorithm;
-  enum Strategy;
-  enum RecombinationScheme;
-  enum AreaType;
-}
-#endif
-
-#include "AliJetHeader.h"
-
-class AliFastJetHeader : public AliJetHeader
-{
- public:
-  AliFastJetHeader();
-  virtual ~AliFastJetHeader() { }
-
-  // Getters
-  Double_t                     GetRparam()            const {return fRparam;}
-  fastjet::JetAlgorithm        GetAlgorithm()         const {return fAlgorithm;}
-  fastjet::Strategy            GetStrategy()          const {return fStrategy;}
-  fastjet::RecombinationScheme GetRecombScheme()      const {return fRecombScheme;}
-  Double_t                     GetGhostEtaMax()       const {return fGhostEtaMax;}
-  Double_t                     GetGhostArea()         const {return fGhostArea;}
-  Int_t                        GetActiveAreaRepeats() const {return fActiveAreaRepeats;}
-  fastjet::AreaType            GetAreaType()          const {return fAreaType;}
-  Double_t                     GetPtMin()             const {return fPtMin;}
-  Double_t                     GetRapMax()            const {return fRapMax;}
-  Double_t                     GetRapMin()            const {return fRapMin;}
-  Double_t                     GetPhiMax()            const {return fPhiMax;}
-  Double_t                     GetPhiMin()            const {return fPhiMin;}
-  
-  // Setters
-  void SetRparam(Double_t f)                           {fRparam = f;}
-  void SetAlgorithm(fastjet::JetAlgorithm f)           {fAlgorithm = f;}
-  void SetStrategy(fastjet::Strategy f)                {fStrategy = f;}
-  void SetRecombScheme(fastjet::RecombinationScheme f) {fRecombScheme = f;}
-  void SetGhostEtaMax(Double_t f)                      {fGhostEtaMax = f;}
-  void SetGhostArea(Double_t f)                        {fGhostArea = f;}
-  void SetActiveAreaRepeats(Int_t f)                   {fActiveAreaRepeats =f;}
-  void SetAreaType(fastjet::AreaType f)                {fAreaType = f;}
-  void SetRapRange(Double_t fmin, Double_t fmax)       {fRapMin = fmin; fRapMax = fmax;}
-  void SetPhiRange(Double_t fmin, Double_t fmax)       {fPhiMin = fmin; fPhiMax = fmax;}
-  
-  void SetComment(TString com)       {fComment=com;}
-  void SetComment(const char* com)   {fComment=com;}
-  
-  // others
-  void PrintParameters() const;
-
- protected:
-
-  //fastjet::JetDefinition parameters
-  Double_t fRparam;
-  fastjet::JetAlgorithm fAlgorithm; //fastjet::kt_algorithm
-  fastjet::Strategy fStrategy;  //= fastjet::Best;
-  fastjet::RecombinationScheme fRecombScheme; // = fastjet::BIpt_scheme;
-  
-  //fastjet::GhostedAreaSpec parameters
-  Double_t fGhostEtaMax;       // max area of ghosts
-  Double_t fGhostArea;         // ghost area
-  Int_t    fActiveAreaRepeats; // number of repetitions of active area 
-  
-  //fastjet::AreaDefinition parameters
-  fastjet::AreaType fAreaType; // the are type
-  
-  //fastjet::ClusterSequenceArea options parameters
-  Double_t fPtMin; //jets with pt > ptmin
-  
-  //fastjet::RangeDefinition parameters 
-  Double_t fRapMax, fRapMin; // rapidity range of background sub 
-  Double_t fPhiMax, fPhiMin; // phi range of background sub
-  
-  
-  ClassDef(AliFastJetHeader,2)
-};
-#endif
index c29def8..da58d59 100644 (file)
@@ -13,6 +13,7 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
+/* $Id$ */
 
 //---------------------------------------------------------------------
 // FastJet v2.3.4 finder algorithm interface
@@ -23,7 +24,6 @@
 #include <Riostream.h>
 #include <TMath.h>
 
-#include "fastjet/ClusterSequenceArea.hh"
 #include "fastjet/AreaDefinition.hh"
 #include "fastjet/JetDefinition.hh"
 
@@ -36,62 +36,56 @@ ClassImp(AliFastJetHeaderV1)
 ////////////////////////////////////////////////////////////////////////
 
 AliFastJetHeaderV1::AliFastJetHeaderV1():
-    AliJetHeader("AliFastJetHeaderV1"),
-    fRparam(0.4),
-    fRparamBkg(0.4),  
-    fAlgorithm(fastjet::kt_algorithm),
-    fBGAlgorithm(fastjet::kt_algorithm),
-    fStrategy(fastjet::Best),
-    fRecombScheme(fastjet::BIpt_scheme),
-    fGhostEtaMax(2.0),
-    fGhostArea(0.01),
-    fActiveAreaRepeats(1),
-    fAreaType(fastjet::active_area), 
-    fPtMin(5.0),
-    fMinCellEt(0.),
-    fRapMax(0.),
-    fRapMin(0.),
-    fPhiMax(TMath::TwoPi()),
-    fPhiMin(0),
-    fBGMode(0),
-    fUse4VectorArea(kFALSE)
+  AliJetHeader("AliFastJetHeaderV1"),
+  fRparam(0.4),
+  fRparamBkg(0.4),  
+  fAlgorithm(fastjet::kt_algorithm),
+  fBGAlgorithm(fastjet::kt_algorithm),
+  fStrategy(fastjet::Best),
+  fRecombScheme(fastjet::BIpt_scheme),
+  fGhostEtaMax(2.0),
+  fGhostArea(0.01),
+  fActiveAreaRepeats(1),
+  fAreaType(fastjet::active_area), 
+  fPtMin(5.0),
+  fMinCellEt(0.),
+  fRapMax(0.),
+  fRapMin(0.),
+  fPhiMax(TMath::TwoPi()),
+  fPhiMin(0),
+  fUse4VectorArea(kFALSE),
+  fkBkgFastJetb(kFALSE),
+  fktBkgFastJetWoHardest(kFALSE)
 {
-  // Constructor
-  
+  // Default constructor
   Double_t rapmax = fGhostEtaMax - fRparam;
   Double_t rapmin = -fGhostEtaMax + fRparam;
   SetRapRange(rapmin, rapmax);
   
 }
 
-////////////////////////////////////////////////////////////////////////
-
+//____________________________________________________________________________
 void AliFastJetHeaderV1::PrintParameters() const
 {
   // prints out parameters of jet algorithm
 
-  cout << "FastJet algorithm  parameters:" << endl;
-  
-  cout << "-- Jet Definition --- " << endl;
-  cout << "R " << fRparam << endl;
-  cout << "Jet Algorithm " << fAlgorithm << endl; 
-  cout << "Bkg Jet Algorithm " << fBGAlgorithm << endl;
-  cout << "Strategy " << fStrategy << endl;  
-  cout << "Recombination Scheme " << fRecombScheme << endl; 
-  
-  cout << "-- Ghosted Area Spec parameters --- " << endl;
-  cout << "Ghost Eta Max " << fGhostEtaMax << endl;
-  cout << "Ghost Area " << fGhostArea << endl;
-  cout << "Active Area Repeats " << fActiveAreaRepeats << endl;
-  
-  cout << "-- Area Definition parameters --- " << endl;
-  cout << "Area Type " << fAreaType << endl; 
-  
+  cout << "FastJet algorithm  parameters:"           << endl;
+  cout << "-- Jet Definition --- "                   << endl;
+  cout << "R "                                       << fRparam << endl;
+  cout << "Jet Algorithm "                           << fAlgorithm << endl; 
+  cout << "Bkg Jet Algorithm "                       << fBGAlgorithm << endl;
+  cout << "Strategy "                                << fStrategy << endl;  
+  cout << "Recombination Scheme "                    << fRecombScheme << endl; 
+  cout << "-- Ghosted Area Spec parameters --- "     << endl;
+  cout << "Ghost Eta Max "                           << fGhostEtaMax << endl;
+  cout << "Ghost Area "                              << fGhostArea << endl;
+  cout << "Active Area Repeats "                     << fActiveAreaRepeats << endl;
+  cout << "-- Area Definition parameters --- "       << endl;
+  cout << "Area Type "                               << fAreaType << endl; 
   cout << "-- Cluster Sequence Area parameters --- " << endl;
-  cout << "pt min " << fPtMin << endl; 
-  
-  cout << "-- Range Definition parameters --- " << endl;
-  cout << " bkg rapidity range from  " << fRapMin << " to " << fRapMax << endl;
-  cout << " bkg phi range from " << fPhiMin << " to " << fPhiMax << endl;
+  cout << "pt min "                                  << fPtMin << endl; 
+  cout << "-- Range Definition parameters --- "      << endl;
+  cout << " bkg rapidity range from  "               << fRapMin << " to " << fRapMax << endl;
+  cout << " bkg phi range from "                     << fPhiMin << " to " << fPhiMax << endl;
 
 }
index dc11d99..f82bd82 100644 (file)
@@ -3,6 +3,8 @@
  
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
  
 //---------------------------------------------------------------------
 // FastJet v2.3.4 finder algorithm interface
 // Author: Rafael.Diaz.Valdes@cern.ch
 //---------------------------------------------------------------------
  
-
 #ifndef __CINT__
-#include "fastjet/ClusterSequenceArea.hh"
-#include "fastjet/AreaDefinition.hh"
-#include "fastjet/JetDefinition.hh"
+# include "fastjet/AreaDefinition.hh"
+# include "fastjet/JetDefinition.hh"
 #else
 namespace fastjet {
   enum JetAlgorithm;
@@ -23,91 +23,88 @@ namespace fastjet {
   enum AreaType;
 }
 #endif
-
 #include "AliJetHeader.h"
 
 class AliFastJetHeaderV1 : public AliJetHeader
 {
  public:
   AliFastJetHeaderV1();
   virtual ~AliFastJetHeaderV1() { }
 
   // Getters
-  Double_t                     GetRparam()            const {return fRparam;}
-  fastjet::JetAlgorithm        GetAlgorithm()         const {return fAlgorithm;}
-  fastjet::JetAlgorithm        GetBGAlgorithm()       const {return fBGAlgorithm;} 
-  fastjet::Strategy            GetStrategy()          const {return fStrategy;}
-  fastjet::RecombinationScheme GetRecombScheme()      const {return fRecombScheme;}
-  Double_t                     GetGhostEtaMax()       const {return fGhostEtaMax;}
-  Double_t                     GetGhostArea()         const {return fGhostArea;}
-  Int_t                        GetActiveAreaRepeats() const {return fActiveAreaRepeats;}
-  fastjet::AreaType            GetAreaType()          const {return fAreaType;}
-  Double_t                     GetPtMin()             const {return fPtMin;}
-  Double_t                     GetRapMax()            const {return fRapMax;}
-  Double_t                     GetRapMin()            const {return fRapMin;}
-  Double_t                     GetPhiMax()            const {return fPhiMax;}
-  Double_t                     GetPhiMin()            const {return fPhiMin;}
-  // Added temporarily !!! To be removed if not necessary
-  Float_t                      GetMinCellEt()         const {return fMinCellEt;} 
-  Bool_t                       GetBGMode()            const {return fBGMode;}
-  Double_t                     GetRparamBkg()            const {return fRparamBkg;}
-  Bool_t                       Use4VectorArea()       const {return fUse4VectorArea;}  
-
+  Double_t                     GetRparam()              const                  {return fRparam;}
+  fastjet::JetAlgorithm        GetAlgorithm()           const                  {return fAlgorithm;}
+  fastjet::JetAlgorithm        GetBGAlgorithm()         const                  {return fBGAlgorithm;}
+  fastjet::Strategy            GetStrategy()            const                  {return fStrategy;}
+  fastjet::RecombinationScheme GetRecombScheme()        const                  {return fRecombScheme;}
+  Double_t                     GetGhostEtaMax()         const                  {return fGhostEtaMax;}
+  Double_t                     GetGhostArea()           const                  {return fGhostArea;}
+  Int_t                        GetActiveAreaRepeats()   const                  {return fActiveAreaRepeats;}
+  fastjet::AreaType            GetAreaType()            const                  {return fAreaType;}
+  Double_t                     GetPtMin()               const                  {return fPtMin;}
+  Double_t                     GetRapMax()              const                  {return fRapMax;}
+  Double_t                     GetRapMin()              const                  {return fRapMin;}
+  Double_t                     GetPhiMax()              const                  {return fPhiMax;}
+  Double_t                     GetPhiMin()              const                  {return fPhiMin;}
+  Bool_t                       GetBGMode()              const                  {return fBGMode;}
+  Double_t                     GetRparamBkg()           const                  {return fRparamBkg;}
+  Bool_t                       Use4VectorArea()         const                  {return fUse4VectorArea;}
+  Bool_t                       GetBkgFastJetb()         const                  {return fkBkgFastJetb;}   
+  Bool_t                       GetBkgFastJetWoHardest() const                  {return fktBkgFastJetWoHardest;}
   // Setters
-  void SetRparam(Double_t f)                           {fRparam = f;}
-  void SetAlgorithm(fastjet::JetAlgorithm f)           {fAlgorithm = f;}
-  void SetBGAlgorithm(fastjet::JetAlgorithm f)         {fBGAlgorithm = f;}
-  void SetStrategy(fastjet::Strategy f)                {fStrategy = f;}
-  void SetRecombScheme(fastjet::RecombinationScheme f) {fRecombScheme = f;}
-  void SetGhostEtaMax(Double_t f)                      {fGhostEtaMax = f;}
-  void SetGhostArea(Double_t f)                        {fGhostArea = f;}
-  void SetActiveAreaRepeats(Int_t f)                   {fActiveAreaRepeats =f;}
-  void SetAreaType(fastjet::AreaType f)                {fAreaType = f;}
-  void SetRapRange(Double_t fmin, Double_t fmax)       {fRapMin = fmin; fRapMax = fmax;}
-  void SetPhiRange(Double_t fmin, Double_t fmax)       {fPhiMin = fmin; fPhiMax = fmax;}
-  void SetPtMin(Double_t ptmin)                        {fPtMin = ptmin;}
-  void SetBGMode(Bool_t bgmode)                        {fBGMode = bgmode;}
-  void SetUse4VectorArea()                             {fUse4VectorArea = kTRUE;}
-  void SetComment(TString com) {fComment=com;}
-  void SetComment(const char* com) {AliJetHeader::SetComment(com);}
-  
-  void SetRparamBkg(Double_t f)                           {fRparamBkg = f;}
-
+  void                         SetRparam(Double_t f)                           {fRparam = f;}
+  void                         SetAlgorithm(fastjet::JetAlgorithm f)           {fAlgorithm = f;}
+  void                         SetBGAlgorithm(fastjet::JetAlgorithm f)         {fBGAlgorithm = f;}
+  void                         SetStrategy(fastjet::Strategy f)                {fStrategy = f;}
+  void                         SetRecombScheme(fastjet::RecombinationScheme f) {fRecombScheme = f;}
+  void                         SetGhostEtaMax(Double_t f)                      {fGhostEtaMax = f;}
+  void                         SetGhostArea(Double_t f)                        {fGhostArea = f;}
+  void                         SetActiveAreaRepeats(Int_t f)                   {fActiveAreaRepeats =f;}
+  void                         SetAreaType(fastjet::AreaType f)                {fAreaType = f;}
+  void                         SetRapRange(Double_t fmin, Double_t fmax)       {fRapMin = fmin; fRapMax = fmax;}
+  void                         SetPhiRange(Double_t fmin, Double_t fmax)       {fPhiMin = fmin; fPhiMax = fmax;}
+  void                         SetPtMin(Double_t ptmin)                        {fPtMin = ptmin;}
+  void                         SetBGMode(Bool_t bgmode)                        {fBGMode = bgmode;}
+  void                         SetUse4VectorArea()                             {fUse4VectorArea = kTRUE;}
+  void                         SetComment(TString com)                         {fComment=com;}
+  void                         SetComment(const char* com)                     {AliJetHeader::SetComment(com);}
+  void                         SetRparamBkg(Double_t f)                        {fRparamBkg = f;}
+  void                         SetBkgFastJetb(Bool_t f = 1)                    {fkBkgFastJetb = f;}     
+  void                         SetBkgFastJetWoHardest(Bool_t f = 1)            {fktBkgFastJetWoHardest = f;}
   // others
-  void PrintParameters() const;
+  void                         PrintParameters() const;
 
  protected:
-
   //fastjet::JetDefinition parameters
-  Double_t fRparam;   // R param
-  Double_t fRparamBkg;//R param for bkg calculation
-  fastjet::JetAlgorithm fAlgorithm; //fastjet::kt_algorithm
-  fastjet::JetAlgorithm fBGAlgorithm; //fastjet::kt_algorithm
-  fastjet::Strategy fStrategy;  //= fastjet::Best;
-  fastjet::RecombinationScheme fRecombScheme; // = fastjet::BIpt_scheme;
+  Double_t                     fRparam;                // R param
+  Double_t                     fRparamBkg;             // R param for bkg calculation
+  fastjet::JetAlgorithm        fAlgorithm;             // fastjet::kt_algorithm
+  fastjet::JetAlgorithm        fBGAlgorithm;           // fastjet::kt_algorithm
+  fastjet::Strategy            fStrategy;              // fastjet::Best;
+  fastjet::RecombinationScheme fRecombScheme;          // fastjet::BIpt_scheme;
   
   //fastjet::GhostedAreaSpec parameters
-  Double_t fGhostEtaMax;       // Max eta for ghosts
-  Double_t fGhostArea;         // Ghost area 
-  Int_t    fActiveAreaRepeats; // Active are repetitions
+  Double_t                     fGhostEtaMax;           // Max eta for ghosts
+  Double_t                     fGhostArea;             // Ghost area 
+  Int_t                        fActiveAreaRepeats;     // Active are repetitions
   
   //fastjet::AreaDefinition parameters
-  fastjet::AreaType fAreaType; // area types
+  fastjet::AreaType            fAreaType;              // area types
   
   //fastjet::ClusterSequenceArea options parameters
-  Double_t fPtMin; //jets with pt > ptmin
-  Float_t  fMinCellEt;       //  Min Et in one cell
+  Double_t                     fPtMin;                 // jets with pt > ptmin
+  Float_t                      fMinCellEt;             // Min Et in one cell
 
   //fastjet::RangeDefinition parameters 
-  Double_t fRapMax, fRapMin; // rapidity range of background sub 
-  Double_t fPhiMax, fPhiMin; // phi range of background sub
-  Bool_t   fBGMode;          // Do we subtract BG or not?
-  Bool_t   fUse4VectorArea;  // Toggle use of 4-vector area 
-
-  ClassDef(AliFastJetHeaderV1,3)
+  Double_t                     fRapMax, fRapMin;       // rapidity range of background sub 
+  Double_t                     fPhiMax, fPhiMin;       // phi range of background sub
+  Bool_t                       fUse4VectorArea;        // Toggle use of 4-vector area
+  
+  //background methods flags
+  Bool_t                       fkBkgFastJetb;          // Toggle background estimation using AliFastJetBkg::BkgFastJetb()
+  Bool_t                       fktBkgFastJetWoHardest; // Toggle background estimation using AliFastJetBkg::BkgFastJetWoHardest()  
+  ClassDef(AliFastJetHeaderV1,4)                       // Fastjet header class
 };
  
 #endif
index 74d9980..89ae79c 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
+/* $Id$ */
+
+//---------------------------------------------------------------------
+// Class for input particles
+// manages the search for jets
+// Authors: Elena Bruna elena.bruna@yale.edu
+//
+// ** 2011 magali.estienne@subatech.in2p3.fr &  alexandre.shabetai@cern.ch
+// Modified accordingly to reader/finder splitting and new handling of neutral information
+//---------------------------------------------------------------------
+
 #include <Riostream.h> 
-#include <TChain.h>
-#include <TFile.h>
-#include <TF1.h>
-#include <TRandom.h>
-#include <TList.h>
-#include <TLorentzVector.h>
-#include <TArrayF.h>
-#include <TClonesArray.h>
 
 #include "AliJetHeader.h"
-#include "AliJetReader.h"
-#include "AliJetReaderHeader.h"
-#include "AliJetHistos.h"
-
-#include "AliFastJetFinder.h"
 #include "AliFastJetHeaderV1.h"
-#include "AliJetReaderHeader.h"
-#include "AliJetReader.h"
-#include "AliJetESDReader.h"
-#include "AliJetUnitArray.h"
 #include "AliFastJetInput.h"
+#include "AliJetCalTrk.h"
 
 #include "fastjet/PseudoJet.hh"
-#include "fastjet/ClusterSequenceArea.hh"
-#include "fastjet/AreaDefinition.hh"
-#include "fastjet/JetDefinition.hh"
-// get info on how fastjet was configured
-#include "fastjet/config.h"
-
-#ifdef ENABLE_PLUGIN_SISCONE
-#include "fastjet/SISConePlugin.hh"
-#endif
 
-#include<sstream>  // needed for internal io
 #include<vector> 
-#include <cmath> 
 
 using namespace std;
 
-
 ClassImp(AliFastJetInput)
 
 ////////////////////////////////////////////////////////////////////////
 
 AliFastJetInput::AliFastJetInput():
-    fReader(0),
-    fHeader(0),
-    fInputParticles(0),
-    fInputParticlesCh(0)
+  fHeader(0x0),
+  fCalTrkEvent(0x0),
+  fInputParticles(0),
+  fInputParticlesCh(0)
 {
   // Default constructor
 }
+
+//______________________________________________________________________
 AliFastJetInput::AliFastJetInput(const AliFastJetInput &input):
-    TObject(),
-    fReader(input.fReader),
-    fHeader(input.fHeader),
-    fInputParticles(input.fInputParticles),
-    fInputParticlesCh(input.fInputParticlesCh)
+  TObject(input),
+  fHeader(input.fHeader),
+  fCalTrkEvent(input.fCalTrkEvent),
+  fInputParticles(input.fInputParticles),
+  fInputParticlesCh(input.fInputParticlesCh)
 {
   // copy constructor
 }
+
 //______________________________________________________________________
-AliFastJetInput& AliFastJetInput::operator=(const AliFastJetInput& source){
-    // Assignment operator. 
-    this->~AliFastJetInput();
-    new(this) AliFastJetInput(source);
-    return *this;
+AliFastJetInput& AliFastJetInput::operator=(const AliFastJetInput& source)
+{
+  // Assignment operator. 
+  if(this!=&source){
+   TObject::operator=(source);
+   fHeader = source.fHeader;
+   fCalTrkEvent = source.fCalTrkEvent;
+   fInputParticles = source.fInputParticles;
+   fInputParticlesCh = source.fInputParticlesCh;
+  }
+
+  return *this;
 
 }
-//___________________________________________________________
-void AliFastJetInput::FillInput(){
-  //cout<<"-------- AliFastJetInput::FillInput()  ----------------"<<endl;
 
+//___________________________________________________________
+void AliFastJetInput::FillInput()
+{
+  // fills input particles for FASTJET based analysis
+  
   AliFastJetHeaderV1 *header = (AliFastJetHeaderV1*)fHeader;
+  Int_t debug  = header->GetDebug();     // debug option
+
+  if(debug>0) cout<<"-------- AliFastJetInput::FillInput()  ----------------"<<endl;
+
   fInputParticles.clear();
   fInputParticlesCh.clear();
 
-  Int_t debug  = header->GetDebug();     // debug option
-  Int_t fOpt   = fReader->GetReaderHeader()->GetDetector();
-
   // RUN ALGORITHM  
   // read input particles -----------------------------
   vector<fastjet::PseudoJet> inputParticles;
-  //  cout<<"=============== AliFastJetInput::FillInput()  =========== fOpt="<<fOpt<<endl;
-  //cout<<"pointers --> fReader="<<fReader<<" header="<<header<<" fHeader="<<fHeader<<endl;
-  //cout<<"Rparam="<<Rparam<<"  ghost_etamax="<<ghost_etamax<<"  ghost_area="<<ghost_area<<endl;
-  //cout<<fReader->ClassName()<<endl;
-
-  if(fOpt==0)
-    {
-      TClonesArray *lvArray = fReader->GetMomentumArray();
-      if(lvArray == 0) { cout << "Could not get the momentum array" << endl; return; }
-      Int_t nIn =  lvArray->GetEntries();
-      if(nIn == 0) { if (debug) cout << "entries = 0 ; Event empty !!!" << endl ; return; }
-      Float_t px,py,pz,en;
-      // load input vectors
-      for(Int_t i = 0; i < nIn; i++){ // loop for all input particles
-       if(fReader->GetCutFlag(i)!=1)continue; // pt cut
-       TLorentzVector *lv = (TLorentzVector*) lvArray->At(i);
-       px = lv->Px();
-       py = lv->Py();
-       pz = lv->Pz();
-       en = lv->Energy();
-       
-       //      cout<<"in FillInput...... "<<i<<" "<<px<<" "<<py<<"  "<<pz<<" "<<en<<endl;
-       fastjet::PseudoJet inputPart(px,py,pz,en); // create PseudoJet object
-       inputPart.set_user_index(i); //label the particle into Fastjet algortihm
-       fInputParticles.push_back(inputPart);  // back of the inputParticles vector  
-      } // end loop 
-    }
-  else {
-    TClonesArray* fUnit = fReader->GetUnitArray();
-    if(fUnit == 0) { cout << "Could not get the momentum array" << endl; return; }
-    Int_t         nIn = fUnit->GetEntries();
-    if(nIn == 0) { if (debug) cout << "entries = 0 ; Event empty !!!" << endl ; return; }
-   
-    // Information extracted from fUnitArray
-    // load input vectors and calculate total energy in array
-    Float_t pt,eta,phi,theta,px,py,pz,en;
-    Int_t ipart = 0;
-    Int_t countUnit=0,countUnitNonZero=0;
-    //cout<<" nIn = "<<nIn<<endl;
-
-    for(Int_t i=0; i<nIn; i++) 
-      {
-       AliJetUnitArray *uArray = (AliJetUnitArray*)fUnit->At(i);
-       if(uArray->GetUnitEnergy()>0.){
-         countUnit++;
-         // It is not necessary anymore to cut on particle pt
-         pt    = uArray->GetUnitEnergy();
-         eta   = uArray->GetUnitEta();
-         phi   = uArray->GetUnitPhi();
-         theta = EtaToTheta(eta);
-         en    = (TMath::Abs(TMath::Sin(theta)) == 0) ? pt : pt/TMath::Abs(TMath::Sin(theta));
-         px    = TMath::Cos(phi)*pt;
-         py    = TMath::Sin(phi)*pt;
-         pz    = en*TMath::TanH(eta);
-         if(debug) cout << "pt: " << pt << ", eta: " << eta << ", phi: " << phi << ", en: " << en << ", px: " << px << ", py: " << py << ", pz: " << pz << endl;
-         //cout << i<<" "<<"pt: " << pt << ", eta: " << eta << ", phi: " << phi << ", en: " << en << ", px: " << px << ", py: " << py << ", pz: " << pz << endl;
-         //cout<<"in FillInput...... "<<i<<" "<<px<<" "<<py<<"  "<<pz<<" "<<en<<endl;
-
-         fastjet::PseudoJet inputPart(px,py,pz,en); // create PseudoJet object
-         inputPart.set_user_index(ipart); //label the particle into Fastjet algortihm
-         fInputParticles.push_back(inputPart);  // back of the inputParticles vector 
-         ipart++;
-
-       
-       
-         //only for charged particles (TPC+ITS)
-         TRefArray* ref = uArray->GetUnitTrackRef();
-         Int_t nRef = ref->GetEntries();
-         for(Int_t j=0; j<nRef;j++){
-           Float_t pxj=0.;  Float_t pyj=0.;  Float_t pzj=0.;Float_t enj=0.;
-           pxj = ((AliVTrack*)ref->At(j))->Px();
-           pyj = ((AliVTrack*)ref->At(j))->Py();
-           pzj = ((AliVTrack*)ref->At(j))->Pz();
-           enj=TMath::Sqrt(pxj*pxj+pyj*pyj+pzj*pzj);
-           fastjet::PseudoJet inputPartCh(pxj,pyj,pzj,enj); // create PseudoJet object
-           inputPartCh.set_user_index(((AliVTrack*)ref->At(j))->GetID()); //label the particle into Fastjet algortihm
-           fInputParticlesCh.push_back(inputPartCh);  // back of the inputParticles vector 
-
-         }
-       }
-      } // End loop on UnitArray 
-    if (debug) cout<<"countUnit(En>0) = "<<countUnit<<"  countUnit with Non ZeroSize = "<<countUnitNonZero<<endl;
-  }
+
+  if(fCalTrkEvent == 0) { cout << "Could not get the CalTrk Event" << endl; return; }
+  Int_t nIn =  fCalTrkEvent->GetNCalTrkTracks() ;
+  if(nIn == 0) { if (debug>0) cout << "entries = 0 ; Event empty !!!" << endl ; return; }
+
+  // Information extracted from fCalTrkEvent
+  // load input vectors and calculate total energy in array
+  Float_t px = -999., py = -999., pz = -999., en = -999.; 
+  // Fill charged tracks
+  for(Int_t i = 0; i < fCalTrkEvent->GetNCalTrkTracks(); i++)
+    { // loop for all input particles
+      if (fCalTrkEvent->GetCalTrkTrack(i)->GetCutFlag() != 1) continue;
+      px =  fCalTrkEvent->GetCalTrkTrack(i)->GetPx();
+      py =  fCalTrkEvent->GetCalTrkTrack(i)->GetPy();
+      pz =  fCalTrkEvent->GetCalTrkTrack(i)->GetPz();
+      en =  fCalTrkEvent->GetCalTrkTrack(i)->GetP();
+
+      fastjet::PseudoJet inputPart(px,py,pz,en);  // create PseudoJet object
+      inputPart.set_user_index(i);      //label the particle into Fastjet algortihm
+      fInputParticles.push_back(inputPart);       // back of the inputParticles vector
+      // only for charged particles (TPC+ITS)
+      fastjet::PseudoJet inputPartCh(px,py,pz,en); // create PseudoJet object
+      inputPartCh.set_user_index(i);               //label the particle into Fastjet algortihm
+      fInputParticlesCh.push_back(inputPartCh);    // back of the inputParticles vector
+    } // End loop on CalTrk
 
 }
 
 //_____________________________________________________________________
-Float_t  AliFastJetInput::EtaToTheta(Float_t arg)
+Double_t AliFastJetInput::Thermalspectrum(const Double_t *x, const Double_t *par)
 {
-  //  return (180./TMath::Pi())*2.*atan(exp(-arg));
-  return 2.*atan(exp(-arg));
-
-
-}
-Double_t AliFastJetInput::Thermalspectrum(const Double_t *x, const Double_t *par){
-
+  // compute an exponential function
   return x[0]*TMath::Exp(-x[0]/par[0]);
 
 }
index 3382d60..d24a38d 100644 (file)
@@ -3,60 +3,59 @@
  
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
-  //---------------------------------------------------------------------
+
+/* $Id$ */
+
+//---------------------------------------------------------------------
 // Class for input particles
 // manages the search for jets 
 // Authors: Elena Bruna elena.bruna@yale.edu
-//         
+//
+// ** 2011 magali.estienne@subatech.in2p3.fr &  alexandre.shabetai@cern.ch             
+// Modified accordingly to reader/finder splitting and new handling of neutral information
 //---------------------------------------------------------------------
 
-//FastJet classes 
+#include <TObject.h>
+
+// FastJet classes 
 #ifndef __CINT__
 # include "fastjet/PseudoJet.hh"
-# include "fastjet/ClusterSequenceArea.hh"
-# include "fastjet/AreaDefinition.hh"
-# include "fastjet/JetDefinition.hh"
-// get info on how fastjet was configured
-# include "fastjet/config.h"
-# ifdef ENABLE_PLUGIN_SISCONE
-#  include "fastjet/SISConePlugin.hh"
-#  include<sstream>  // needed for internal io
-#  include <vector> 
-#  include <cmath> 
-# endif
 #else
 namespace fastjet {
-class PseudoJet;
+  class PseudoJet;
 }
 #endif
-class AliJetFinder;
+
+#include <vector> 
+
+class AliJetCalTrkEvent;
 class AliJetHeader;
-class AliJetReader;
 
+using std::vector;
 
 class AliFastJetInput : public TObject
 {
  public:
-    AliFastJetInput();
-    AliFastJetInput(const AliFastJetInput &input);
-    AliFastJetInput& operator=(const AliFastJetInput& source);
-    virtual ~AliFastJetInput() {;}
-    void SetHeader(AliJetHeader *header)  {fHeader=header;}
-    void SetReader(AliJetReader *reader)  {fReader=reader;}
-    void FillInput();
-    vector<fastjet::PseudoJet> GetInputParticles()   const {return fInputParticles;}
-    vector<fastjet::PseudoJet> GetInputParticlesCh() const {return fInputParticlesCh;}
-    Float_t  EtaToTheta(Float_t arg);
-    static Double_t Thermalspectrum(const Double_t *x, const Double_t *par);
+  AliFastJetInput();
+  AliFastJetInput(const AliFastJetInput &input);
+  AliFastJetInput& operator=(const AliFastJetInput& source);
+  virtual                    ~AliFastJetInput() {;}
+  void                       SetHeader(AliJetHeader *header)            {fHeader=header;}
+  void                       SetCalTrkEvent(AliJetCalTrkEvent *caltrk)  {fCalTrkEvent=caltrk;}
+  void                       FillInput();
+  vector<fastjet::PseudoJet> GetInputParticles()   const                {return fInputParticles;}
+  vector<fastjet::PseudoJet> GetInputParticlesCh() const                {return fInputParticlesCh;}
+  static Double_t            Thermalspectrum(const Double_t *x, const Double_t *par);
 
  private:
-   AliJetReader *fReader;  //! reader 
-   AliJetHeader *fHeader;  //! header 
+  AliJetHeader *fHeader;                        //! header 
+  AliJetCalTrkEvent *fCalTrkEvent;              //! caltrkevent
    
-    vector<fastjet::PseudoJet> fInputParticles;     //! input particles for FastJet
-    vector<fastjet::PseudoJet> fInputParticlesCh;   //! input charged particles for FastJet
+  vector<fastjet::PseudoJet> fInputParticles;   //! input particles for FastJet
+  vector<fastjet::PseudoJet> fInputParticlesCh; //! input charged particles for FastJet
 
-  ClassDef(AliFastJetInput, 1); // Analysis task for standard jet analysis
+  ClassDef(AliFastJetInput, 2)                  //  fills input particles for FASTJET based analysis
+    
 };
  
 #endif
diff --git a/JETAN/AliJetAODFillUnitArrayEMCalDigits.cxx b/JETAN/AliJetAODFillUnitArrayEMCalDigits.cxx
deleted file mode 100755 (executable)
index 8efda07..0000000
+++ /dev/null
@@ -1,495 +0,0 @@
-
-/**************************************************************************
- * 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.                  *
- **************************************************************************/
-//======================================================================
-// Fill Unit Array 
-// Called by AOD reader for jet analysis
-// Author: Magali Estienne (magali.estienne@ires.in2p3.fr)
-//======================================================================
-
-class TSystem;
-class TLorentzVector;
-class TGeoManager;
-class TArrayS;
-
-// --- AliRoot header files ---
-#include "AliJetUnitArray.h"
-#include "AliJetAODFillUnitArrayEMCalDigits.h"
-class AliJetFinder;
-
-// #include "AliEMCALCalibData.h"
-// #include "AliCDBManager.h"
-// class AliCDBStorage;
-// #include "AliCDBEntry.h"
-
-
-ClassImp(AliJetAODFillUnitArrayEMCalDigits)
-
-//_____________________________________________________________________________
-AliJetAODFillUnitArrayEMCalDigits::AliJetAODFillUnitArrayEMCalDigits()
-  : AliJetFillUnitArray(),
-    fAOD(0),
-    fNIn(0),
-    fCluster(0),
-    fNCEMCAL(0),
-    fNCPHOS(0),
-    fNCCalo(0),
-    fApplyElectronCorrection(kFALSE),
-    fApplyFractionHadronicCorrection(kFALSE),
-    fFractionHadronicCorrection(0.3),
-    fClus(0x0),
-    fNDigitEmcal(0),
-    fNDigitEmcalCut(0)
-{
-  // constructor
-}
-
-//_____________________________________________________________________________
-AliJetAODFillUnitArrayEMCalDigits::AliJetAODFillUnitArrayEMCalDigits(AliAODEvent *aod)
-  : AliJetFillUnitArray(),
-    fAOD(aod),
-    fNIn(0),
-    fCluster(0),
-    fNCEMCAL(0),
-    fNCPHOS(0),
-    fNCCalo(0),
-    fApplyElectronCorrection(kFALSE),
-    fApplyFractionHadronicCorrection(kFALSE),
-    fFractionHadronicCorrection(0.3),
-    fClus(0x0),
-    fNDigitEmcal(0),
-    fNDigitEmcalCut(0)
-{
-  // constructor
-}
-
-//_____________________________________________________________________________
-AliJetAODFillUnitArrayEMCalDigits::AliJetAODFillUnitArrayEMCalDigits(const AliJetAODFillUnitArrayEMCalDigits &det)
-  : AliJetFillUnitArray(det),
-    fAOD(det.fAOD),
-    fNIn(det.fNIn),
-    fCluster(det.fCluster),
-    fNCEMCAL(det.fNCEMCAL),
-    fNCPHOS(det.fNCPHOS),
-    fNCCalo(det.fNCCalo),
-    fApplyElectronCorrection(det.fApplyElectronCorrection),
-    fApplyFractionHadronicCorrection(det.fApplyFractionHadronicCorrection),
-    fFractionHadronicCorrection(det.fFractionHadronicCorrection),
-    fClus(det.fClus),
-    fNDigitEmcal(det.fNDigitEmcal),
-    fNDigitEmcalCut(det.fNDigitEmcalCut)
-{
-  // Copy constructor
-}
-
-//_____________________________________________________________________________
-AliJetAODFillUnitArrayEMCalDigits& AliJetAODFillUnitArrayEMCalDigits::operator=(const AliJetAODFillUnitArrayEMCalDigits& other)
-{
-  // Assignment
-
-  fAOD = other.fAOD;
-  fNIn = other.fNIn;
-  fCluster = other.fCluster;
-  fNCEMCAL = other.fNCEMCAL;
-  fNCPHOS = other.fNCPHOS;
-  fNCCalo = other.fNCCalo;
-  fApplyElectronCorrection = other.fApplyElectronCorrection;
-  fApplyFractionHadronicCorrection = other.fApplyFractionHadronicCorrection;
-  fFractionHadronicCorrection = other.fFractionHadronicCorrection;
-  fClus = other.fClus;
-  fNDigitEmcal = other.fNDigitEmcal;
-  fNDigitEmcalCut = other.fNDigitEmcalCut;
-
-  return (*this);
-
-}
-
-//_____________________________________________________________________________
-AliJetAODFillUnitArrayEMCalDigits::~AliJetAODFillUnitArrayEMCalDigits()
-{
-  // destructor
-}
-
-
-
-//_____________________________________________________________________________
-void AliJetAODFillUnitArrayEMCalDigits::Exec(Option_t* const /*option*/)
-//void AliJetAODFillUnitArrayEMCalDigits::Exec(Option_t* option)
-{
-  //
-  // Main method.
-  // Fill the unit array with the neutral particle information from the EMCal cells in AOD
-
-  fDebug = fReaderHeader->GetDebug();
-  fOpt = fReaderHeader->GetDetector();
-  fCluster = fReaderHeader->GetCluster();
-
-  // Init parameters
-  //  InitParameters();
-
-  Int_t   goodDigit      = 0;
-  Int_t   index          = 0;
-
-  if(!fCluster) { // Keep all digit information
-
-    // Loop over all cell information
-    //------------------------------------------------------------------
-    AliAODCaloCells &cells= *(fAOD->GetEMCALCells());
-    Int_t ncell = cells.GetNumberOfCells() ;
-//(not used ?)    Int_t type = cells.GetType();
-
-    for (Int_t icell=  0; icell <  ncell; icell++) {
-      Int_t   digitID   = cells.GetCellNumber(icell);
-      Float_t digitAmp  = cells.GetAmplitude(icell);
-      Float_t digitEn   = digitAmp*0.0153; // Last correct
-      //  Float_t digitEn = Calibrate(digitAmp,digitID);
-
-      Float_t etaD=-10., phiD=-10.;
-      fGeom->EtaPhiFromIndex(digitID,etaD,phiD); 
-      //  fEMCalGrid->GetEtaPhiFromIndex2(digitID,phiD,etaD);
-
-      phiD = ((phiD < 0) ? phiD + 2.* TMath::Pi() : phiD);
-      
-      //      Float_t digitEt = digitEn*TMath::Abs(TMath::Sin(EtaToTheta(etaD)));
-
-      AliJetUnitArray *uArray = (AliJetUnitArray*)fUnitArray->At(digitID);
-
-      if(uArray->GetUnitEnergy() == 0.) goodDigit++;
-      uArray->SetUnitTrackID(digitID);
-      
-      Float_t unitEnergy = 0.;
-      Bool_t ok = kFALSE;
-      unitEnergy = uArray->GetUnitEnergy();
-
-      if(unitEnergy==0){
-       if(!fProcId){
-         new(fRefArray) TRefArray(TProcessID::GetProcessWithUID(uArray));
-         fProcId = kTRUE;
-       }
-       fRefArray->Add(uArray);
-       fNDigitEmcal++;
-       ok = kTRUE;
-      }
-
-      // Hadronic Correction
-      double correction=0;
-// Temporarily commented - will be updated removing the AliAODpid dependence
-/*
-      if (fApplyFractionHadronicCorrection) {
-        TArrayS* matched = new TArrayS();
-       GetTracksPointingToCell(matched, etaD, phiD,0.02);
-
-       double ptot = 0;
-       for(int itrack = 0; itrack <  matched->GetSize(); itrack++)
-         {
-           const short indexS = matched->At(itrack);
-           if (indexS>-1)
-             { 
-               AliAODTrack *track = fAOD->GetTrack(indexS);
-               ptot += track->P();
-             }
-         }
-       
-       correction = ptot * fFractionHadronicCorrection;
-
-       if (ptot>0 && fDebug>1 ) {
-          printf("SUM of track momentum for this cell: p=%f \n", ptot);        
-          printf("fractional correction=%f \n", fFractionHadronicCorrection);
-          printf("TOTAL correction=%f \n", correction );
-       }
-       
-       delete matched;
-       
-      }//end hadronic correction
-*/
-      double enerCorr = digitEn;
-      if (correction >= enerCorr) enerCorr = 0;
-      else enerCorr -= correction;
-      if (correction>0 && fDebug>1) {
-        printf("AliJetAODFillUnitArrayEMCALDigits---Hadronic Correction: uncorrected E=%f, corrected E=%f \n", digitEn, enerCorr);
-      }
-
-      Float_t digitEt = enerCorr*TMath::Abs(TMath::Sin(EtaToTheta(etaD)));
-
-      // Detector flag
-      if(unitEnergy>0.)
-       uArray->SetUnitDetectorFlag(kAll);
-      else uArray->SetUnitDetectorFlag(kEmcal);
-      
-      uArray->SetUnitEnergy(unitEnergy+digitEt);
-
-      uArray->SetUnitCutFlag(kPtHigher);
-
-      // To be modified !!!
-      uArray->SetUnitSignalFlag(kGood);
-       
-      // This is for jet multiplicity
-      uArray->SetUnitClusterID(index);
-       
-      if(fDebug > 12) printf("goodDigit : %d\n", goodDigit);
-      
-    } // End loop over cells
-  } // end if !fCluster
-  else { // Keep digit information from clusterization
-
-    // Loop over calo clusters
-    //------------------------------------------------------------------
-
-    // select EMCAL clusters only
-    TRefArray * caloClusters  = new TRefArray();
-    fAOD->GetEMCALClusters(caloClusters);
-
-    // Total number of EMCAL cluster
-    Int_t nclus = caloClusters->GetEntries() ;
-    Int_t beg   = 0;
-    Float_t pos[3] ;
-
-    // Get CaloCells
-    AliAODCaloCells &cells= *(fAOD->GetEMCALCells());
-
-    for(Int_t j = beg; j < nclus; j++) { // loop over clusters
-      // Retrieve cluster from aod
-      fClus = (AliAODCaloCluster *) caloClusters->At(j) ;
-
-      // Get the cluster info
-
-      fClus->GetPosition(pos) ;
-      TVector3 vpos(pos[0],pos[1],pos[2]) ;
-
-      Int_t     digMult = fClus->GetNCells() ;
-      UShort_t *digID   = fClus->GetCellsAbsId() ;
-      Int_t     trackIndex = -1;
-      if(fClus->GetNTracksMatched()!=0) 
-       trackIndex = ((AliAODTrack*)fClus->GetTrackMatched(0))->GetID();
-
-      // Do double-counted electron correction 
-      if (fApplyElectronCorrection != 0 && trackIndex !=-1 )
-       {
-          // The electron correction go there
-          // Under construction !!!!
-       }  // End of Electron correction
-
-      // Get CaloCells of cluster and fill the unitArray
-      for(Int_t i = 0; i < digMult ; i++) {
-        Int_t    digitID      = digID[i]; // or clus->GetCellNumber(i) ;
-        Float_t  digitAmp     = cells.GetCellAmplitude(digitID) ;
-
-        // Calibration for an energy in GeV
-        Float_t digitEn = digitAmp*0.0153;
-
-        Float_t etaD=-10., phiD=-10.;
-        fGeom->EtaPhiFromIndex(digitID,etaD,phiD);
-        //  fEMCalGrid->GetEtaPhiFromIndex2(digitID,phiD,etaD);
-
-        phiD = ((phiD < 0) ? phiD + 2.* TMath::Pi() : phiD);
-
-       // Hadronic Correction
-       double correction=0;
-// Temporarily commented - will be updated removing the AliAODpid dependence
-/*
-       if (fApplyFractionHadronicCorrection) {
-         TArrayS* matched = new TArrayS();
-         GetTracksPointingToCell(matched, etaD, phiD,0.02);
-         
-         double ptot = 0;
-         for(int itrack = 0; itrack <  matched->GetSize(); itrack++)
-           {
-             const short indexS = matched->At(itrack);
-             if (indexS>-1)
-               {       
-                 AliAODTrack *track = fAOD->GetTrack(indexS);
-                 ptot += track->P();
-               }
-           }
-       
-         correction = ptot * fFractionHadronicCorrection;
-
-         if (ptot>0 && fDebug>1 ) {
-           printf("SUM of track momentum for this cell: p=%f \n", ptot);       
-           printf("fractional correction=%f \n", fFractionHadronicCorrection);
-           printf("TOTAL correction=%f \n", correction );
-         }
-       
-         delete matched;
-       
-       }//end hadronic correction
-*/     
-       double enerCorr = digitEn;
-       if (correction >= enerCorr) enerCorr = 0;
-       else enerCorr -= correction;
-       if (correction>0 && fDebug>1) {
-         printf("AliJetAODFillUnitArrayEMCALDigits---Hadronic Correction: uncorrected E=%f, corrected E=%f \n", digitEn, enerCorr);
-       }
-
-       Float_t digitEt = enerCorr*TMath::Abs(TMath::Sin(EtaToTheta(etaD)));
-
-       AliJetUnitArray *uArray = (AliJetUnitArray*)fUnitArray->At(digitID);
-       if(uArray->GetUnitEnergy() == 0.) goodDigit++;
-       uArray->SetUnitTrackID(digitID);
-
-       Float_t unitEnergy = 0.;
-       Bool_t ok = kFALSE;
-       unitEnergy = uArray->GetUnitEnergy();
-
-       if(unitEnergy==0){
-         if(!fProcId){
-           new(fRefArray) TRefArray(TProcessID::GetProcessWithUID(uArray));
-           fProcId = kTRUE;
-         }
-         fRefArray->Add(uArray);
-         fNDigitEmcal++;
-         ok = kTRUE;
-       }
-
-       // Detector flag
-       if(unitEnergy>0.)
-         uArray->SetUnitDetectorFlag(kAll);
-       else uArray->SetUnitDetectorFlag(kEmcal);
-      
-       uArray->SetUnitEnergy(unitEnergy+digitEt);
-
-       uArray->SetUnitCutFlag(kPtHigher);
-
-       // Signal or background
-       // To be modified !!!
-       uArray->SetUnitSignalFlag(kGood);
-
-       // This is for jet multiplicity
-       uArray->SetUnitClusterID(index);
-       
-       if(fDebug > 12) printf("goodDigit : %d\n", goodDigit);
-
-      }// End loop over cells
-    } // End loop over clusters
-  } // end else
-
-  fNIn += goodDigit;
-
-  if(fDebug>1)
-    {
-      printf("End of digits %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%");
-      printf("goodDigit : %d\n", goodDigit);
-    }
-}
-
-////____________________________________________________________________________
-//void AliJetAODFillUnitArrayEMCalDigits::GetTracksPointingToCell(TArrayS* array,Double_t eta, Double_t phi, Double_t cut)
-//{ // Temporarily commented -> will be corrected removing the dependence to AliAODPid
-//// Get all tracks pointing to cell 
-//  int size=0;
-//  
-//  for (Int_t itrk =  0; itrk <  fAOD->GetNumberOfTracks() ; itrk++) { //track loop
-//  
-//    AliAODTrack * track = (AliAODTrack*) fAOD->GetTrack(itrk) ;  
-//    AliAODPid*    pid   = (AliAODPid*) track->GetDetPid();
-//    
-//    if(pid) {
-//      Double_t emcpos[3];
-//      pid->GetEMCALPosition(emcpos);      
-//      TVector3 tpos(emcpos[0],emcpos[1],emcpos[2]);
-//
-//      Double_t deta = tpos.Eta() - eta;
-//      Double_t dphi = tpos.Phi() - phi;
-//
-//      if(dphi > TMath::Pi()) dphi -= 2*TMath::Pi();
-//      if(dphi < -TMath::Pi()) dphi += 2*TMath::Pi();
-//
-//      Double_t res = sqrt(dphi*dphi + deta*deta);
-//      
-//      if (res< cut) {
-//        //add this track-index
-//        size++;
-//        array->Set( size );
-//        array->AddAt( itrk, (size-1) ); 
-//     if(fDebug>1) printf("MTH:: track %d matched cell at eta=%f , phi=%f \n", itrk, eta, phi);
-//                   
-//      }
-//    }
-//  }
-//
-//}
-
-/*
-//____________________________________________________________________________
-void AliJetAODFillUnitArrayEMCalDigits::GetCalibrationParameters()
-{
-  // Set calibration parameters:
-  // if calibration database exists, they are read from database,
-  // otherwise, they are taken from digitizer.
-  //
-  // It is a user responsilibity to open CDB before reconstruction,
-  // for example:
-  // AliCDBStorage* storage = AliCDBManager::Instance()->GetStorage("local://CalibDB");
-
-  //Check if calibration is stored in data base
-
-  if(!fCalibData && (AliCDBManager::Instance()->IsDefaultStorageSet()))
-    {
-      AliCDBEntry *entry = (AliCDBEntry*)
-        AliCDBManager::Instance()->Get("EMCAL/Calib/Data");
-      if (entry) fCalibData =  (AliEMCALCalibData*) entry->GetObject();
-    }
-
-  if(!fCalibData)
-    printf("************* Calibration parameters not found in CDB! ****************");
-//    AliFatal("Calibration parameters not found in CDB!");
-
-
-}
-
-//____________________________________________________________________________
-Float_t  AliJetAODFillUnitArrayEMCalDigits::Calibrate(Int_t amp, Int_t AbsId)
-{
-
-  // Convert digitized amplitude into energy.
-  // Calibration parameters are taken from calibration data base for raw data,
-  // or from digitizer parameters for simulated data.
-
-  if(fCalibData){
-
-    if (fGeom==0)
-      printf("************* Did not get geometry from EMCALLoader ***************");
-//      AliFatal("Did not get geometry from EMCALLoader") ;
-
-    Int_t iSupMod = -1;
-    Int_t nModule  = -1;
-    Int_t nIphi   = -1;
-    Int_t nIeta   = -1;
-    Int_t iphi    = -1;
-    Int_t ieta    = -1;
-
-    Bool_t bCell = fGeom->GetCellIndex(AbsId, iSupMod, nModule, nIphi, nIeta) ;
-    if(!bCell) {
-      // fGeom->PrintGeometry();
-      Error("Calibrate()"," Wrong cell id number : %i", AbsId);
-      assert(0);
-    }
-
-    fGeom->GetCellPhiEtaIndexInSModule(iSupMod,nModule,nIphi, nIeta,iphi,ieta);
-
-    fADCchannelECA  = fCalibData->GetADCchannel (iSupMod,ieta,iphi);
-    fADCpedestalECA = fCalibData->GetADCpedestal(iSupMod,ieta,iphi);
-
-   return -fADCpedestalECA + amp * fADCchannelECA ;
-
-  }
-  else //Return energy with default parameters if calibration is not available
-    return -fADCpedestalECA + amp * fADCchannelECA ;
-
-}
-*/
-
-
diff --git a/JETAN/AliJetAODFillUnitArrayEMCalDigits.h b/JETAN/AliJetAODFillUnitArrayEMCalDigits.h
deleted file mode 100755 (executable)
index 4277abc..0000000
+++ /dev/null
@@ -1,79 +0,0 @@
-#ifndef ALIJETAODFILLUNITARRAYEMCALDIGITS_H
-#define ALIJETAODFILLUNITARRAYEMCALDIGITS_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-//---------------------------------------------------------------------
-// Jet Fill Unit Array 
-// Called by ESD Reader for jet analysis
-// Author: Magali Estienne (magali.estienne@subatech.in2p3.fr)
-//---------------------------------------------------------------------
-
-#include "AliJetFillUnitArray.h"
-
-class AliESDCaloCluster;
-class AliJetReader;
-class AliJetAODReader;
-
-class AliJetAODFillUnitArrayEMCalDigits : public AliJetFillUnitArray
-{
- public: 
-  AliJetAODFillUnitArrayEMCalDigits();
-  AliJetAODFillUnitArrayEMCalDigits(AliAODEvent *fAOD);
-  virtual ~AliJetAODFillUnitArrayEMCalDigits();
-  
-  // Setter
-  void SetApplyElectronCorrection(Int_t flag = 1)     {fApplyElectronCorrection = flag;}
-  void SetApplyFractionHadronicCorrection(Bool_t val) {fApplyFractionHadronicCorrection = val;}
-  void SetFractionHadronicCorrection(Double_t val)    {fFractionHadronicCorrection = val;}
-  void SetAOD(AliAODEvent* const aod)                 {fAOD = aod;}
-  void SetInitMult(Int_t mult)                        {fNDigitEmcal = mult;}
-  void SetInitMultCut(Int_t multcut)                  {fNDigitEmcalCut = multcut;}
-
-  // Getter
-  Int_t         GetMult()      const {return fNDigitEmcal;}
-  Int_t         GetMultCut()   const {return fNDigitEmcalCut;}
-
-  // For calibration 
-  //  virtual Float_t Calibrate(Int_t amp, Int_t cellId) ;  // Tranforms Amp to energy
-
-  // Other
-  void Exec(Option_t* const option);
-
- protected:
-  AliAODEvent  *fAOD;                 // ESD
-  Int_t        fNIn;                  // Number of Array filled in UnitArray
-  Int_t        fCluster;              // Use all cells or cells in clusters for jet finding 
-  Int_t        fNCEMCAL;              // Number of clusters in EMCAL
-  Int_t        fNCPHOS;               // Number of clusters in PHOS
-  Int_t        fNCCalo;               // Number of cluster in EMCAL + PHOS calorimeters
-
-  Bool_t       fApplyElectronCorrection;          // Electron correction flag
-  Bool_t       fApplyFractionHadronicCorrection;  // Fraction hadronic correction flag
-  Double_t     fFractionHadronicCorrection;       // Fraction hadronic correction 
-
-  //Track-matching (mth)
-// Temporarily commented - will be updated removing the AliAODpid dependence
-//  void GetTracksPointingToCell(TArrayS *arr, Double_t eta, Double_t phi, Double_t res);
-
-  // geometry info
-  AliAODCaloCluster *fClus;           //! 
-  Int_t fNDigitEmcal;                 //!
-  Int_t fNDigitEmcalCut;              //!
-  //Calibration parameters... to be replaced by database
-//  AliEMCALCalibData *fCalibData;     //! Calibration database if aval
-//  Float_t            fADCchannelECA; // width of one ADC channel for EC section (GeV)
-//  Float_t            fADCpedestalECA;// pedestal of ADC for EC section (GeV)
-
-
- private:
-  AliJetAODFillUnitArrayEMCalDigits(const AliJetAODFillUnitArrayEMCalDigits &det);
-  AliJetAODFillUnitArrayEMCalDigits &operator=(const AliJetAODFillUnitArrayEMCalDigits &det);
-
-//  void    GetCalibrationParameters(void) ;
-  
-  ClassDef(AliJetAODFillUnitArrayEMCalDigits,1) // Fill Unit Array with tpc and/or emcal information
-};
-
-#endif
diff --git a/JETAN/AliJetAODFillUnitArrayTracks.cxx b/JETAN/AliJetAODFillUnitArrayTracks.cxx
deleted file mode 100644 (file)
index f91ef10..0000000
+++ /dev/null
@@ -1,714 +0,0 @@
-/**************************************************************************
- * 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.                  *
- **************************************************************************/
-
-
-//======================================================================
-// ***July 2006
-// Fill Unit Array class 
-// Class used by AliJetESDReader to fill a UnitArray from the information extracted 
-// from the particle tracks
-// Author: magali.estienne@ires.in2p3.fr
-//======================================================================
-
-
-// --- ROOT system ---
-#include <TVector3.h>
-#include <TProcessID.h>
-
-#include "AliJetUnitArray.h"
-#include "AliJetHadronCorrectionv1.h"
-#include "AliJetAODFillUnitArrayTracks.h"
-
-// --- ROOT system ---
-class TSystem;
-class TLorentzVector;
-class TGeoManager;
-
-// --- AliRoot header files ---
-class AliJetFinder;
-
-using std::cout;
-using std::endl;
-ClassImp(AliJetAODFillUnitArrayTracks)
-
-//_____________________________________________________________________________
-AliJetAODFillUnitArrayTracks::AliJetAODFillUnitArrayTracks()
-  : AliJetFillUnitArray(),
-    fNumUnits(0),
-    fHadCorr(0),
-    fApplyMIPCorrection(kTRUE),
-    fAOD(0x0),
-    fGrid0(0x0),
-    fGrid1(0x0),
-    fGrid2(0x0),
-    fGrid3(0x0),
-    fGrid4(0x0)
-{
-  // constructor
-}
-
-//_____________________________________________________________________________
-AliJetAODFillUnitArrayTracks::AliJetAODFillUnitArrayTracks(AliAODEvent* aod)
-  : AliJetFillUnitArray(),
-    fNumUnits(0),
-    fHadCorr(0),
-    fApplyMIPCorrection(kTRUE),
-    fAOD(aod),
-    fGrid0(0x0),
-    fGrid1(0x0),
-    fGrid2(0x0),
-    fGrid3(0x0),
-    fGrid4(0x0)
-{
-  // constructor
-}
-
-//_____________________________________________________________________________
-AliJetAODFillUnitArrayTracks::AliJetAODFillUnitArrayTracks(const AliJetAODFillUnitArrayTracks &det)
-  : AliJetFillUnitArray(det),
-    fNumUnits(det.fNumUnits),
-    fHadCorr(det.fHadCorr),
-    fApplyMIPCorrection(det.fApplyMIPCorrection),
-    fAOD(det.fAOD),
-    fGrid0(det.fGrid0),
-    fGrid1(det.fGrid1),
-    fGrid2(det.fGrid2),
-    fGrid3(det.fGrid3),
-    fGrid4(det.fGrid4)
-{
-  // Copy constructor
-}
-
-//_____________________________________________________________________________
-AliJetAODFillUnitArrayTracks& AliJetAODFillUnitArrayTracks::operator=(const AliJetAODFillUnitArrayTracks& other)
-{
-  // Assignment
-
-    fNumUnits = other.fNumUnits;
-    fHadCorr = other.fHadCorr;
-    fApplyMIPCorrection = other.fApplyMIPCorrection;
-    fAOD = other.fAOD;
-    fGrid0 = other.fGrid0;
-    fGrid1 = other.fGrid1;
-    fGrid2 = other.fGrid2;
-    fGrid3 = other.fGrid3;
-    fGrid4 = other.fGrid4;
-
-    return (*this);
-}
-
-//____________________________________________________________________________
-void AliJetAODFillUnitArrayTracks::InitParameters()
-{
-  //  fHadCorr        = 0;     // For hadron correction
-  fNumUnits = fGeom->GetEMCGeometry()->GetNCells();      // Number of towers in EMCAL
-
-  fTPCGrid->GetAccParam(fNphi,fNeta,fPhiMin, 
-                       fPhiMax,fEtaMin,fEtaMax);
-  fTPCGrid->GetBinParam(fPhiBinInTPCAcc,fEtaBinInTPCAcc, 
-                       fPhiBinInEMCalAcc,fEtaBinInEMCalAcc,fNbinPhi);
-
-  fIndex = fTPCGrid->GetIndexObject();
-
-  if(fDebug>20){
-    for(Int_t i=0; i<fNphi+1; i++)
-      for(Int_t j=0; j<fNeta+1; j++) {cout << "fIndex[" << i << "," << j << "] : " <<
-         (*fIndex)(i,j) << endl; }
-  } 
-  if(fDebug>1) printf("\n Parameters initiated ! \n");
-}
-
-//_____________________________________________________________________________
-AliJetAODFillUnitArrayTracks::~AliJetAODFillUnitArrayTracks()
-{
-  // destructor
-}
-
-//_____________________________________________________________________________
-void AliJetAODFillUnitArrayTracks::Exec(Option_t* const /*option*/)
-//void AliJetAODFillUnitArrayTracks::Exec(Option_t* option)
-{
-  //
-  // Main method.
-  // Fill the unit array with the charged particle information in AOD
-  //
-
-  fDebug = fReaderHeader->GetDebug();
-  
-  // Set parameters
-  InitParameters();
-  fRef->Clear();
-
-  // get number of tracks in event (for the loop)
-  Int_t goodTrack = 0;
-  Int_t nt = 0;
-//(not used ?)  Int_t nt2 = 0;
-  Int_t nmax = 0;
-  Float_t pt,eta,phi;
-  //  Int_t sflag = 0;
-  TVector3 p3;
-
-  nt = fAOD->GetNumberOfTracks();
-  if(fDebug>1) cout << "Number of Tracks in AOD : " << nt << endl;
-
-  // temporary storage of signal and pt cut flag
-  Int_t* sflag  = new Int_t[nt];
-  Int_t* cflag  = new Int_t[nt];
-
-  // get cuts set by user
-  Float_t ptMin  = fReaderHeader->GetPtCut();
-  Float_t etaMin = fReaderHeader->GetFiducialEtaMin();
-  Float_t etaMax = fReaderHeader->GetFiducialEtaMax();  
-  fOpt = fReaderHeader->GetDetector();
-  fDZ  = fReaderHeader->GetDZ();
-  UInt_t  filterMask =  ((AliJetAODReaderHeader*)fReaderHeader)->GetTestFilterMask();
-
-  Int_t nTracksEmcal      = 0;
-  Int_t nTracksEmcalDZ    = 0;
-  Int_t nTracksTpc        = 0;
-  Int_t nTracksTpcOnly    = 0;
-  Int_t nTracksEmcalCut   = 0;
-  Int_t nTracksEmcalDZCut = 0;
-  Int_t nTracksTpcCut     = 0;
-  Int_t nTracksTpcOnlyCut = 0;
-
-  fGrid = fTPCGrid->GetGridType();
-
-  //loop over tracks
-    nmax = nt;  
-    for (Int_t it = 0; it < nmax; it++) {
-      AliAODTrack *track;
-      track = fAOD->GetTrack(it);
-      UInt_t status = track->GetStatus();
-    
-      Double_t mom[3];
-      track->GetPxPyPz(mom);
-
-      p3.SetXYZ(mom[0],mom[1],mom[2]);
-      pt = p3.Pt();
-
-      eta = p3.Eta();
-      phi = ( (p3.Phi()) < 0) ? (p3.Phi()) + 2. * TMath::Pi() : (p3.Phi());
-      if (status == 0) continue;
-      if((filterMask>0)&&!(track->TestFilterBit(filterMask)))continue;
-
-      if ( (eta > etaMax) || (eta < etaMin)) continue;           // checking eta cut
-      
-      if (goodTrack == 0) new(fRef) TRefArray(TProcessID::GetProcessWithUID(track));
-    
-      sflag[goodTrack]=0;
-      if (TMath::Abs(track->GetLabel()) < 10000) sflag[goodTrack]=1;
-      cflag[goodTrack]=0;
-      if (pt > ptMin) cflag[goodTrack]=1;                       // pt cut
-      fRef->Add(track);
-
-      if(fGrid==0)
-       {
-         // Only TPC filled from its grid in its total acceptance
-         
-         Int_t idTPC = fTPCGrid->GetIndex(phi,eta);
-         Bool_t ok = kFALSE;
-         Bool_t ref = kFALSE;
-
-         AliJetUnitArray *uArray = (AliJetUnitArray*)fUnitArray->At(idTPC-1);
-         TRefArray *reference = uArray->GetUnitTrackRef();
-         if (reference->GetEntries() == 0)  {
-             new(reference) TRefArray(TProcessID::GetProcessWithUID(track));
-         }
-             
-         reference->Add(track);
-
-         Float_t unitEnergy = 0.;
-         unitEnergy = uArray->GetUnitEnergy();
-         // nTracksTpcOnly is necessary to count the number of candidate cells
-         // but it doesn't give the real multiplicity -> it will be extracted 
-         // in the jet finder through the reference to tracks
-         if(unitEnergy==0.){
-           nTracksTpcOnly++;
-           ok = kTRUE;
-            ref = kTRUE;
-         }
-
-         // Fill energy in TPC acceptance
-         uArray->SetUnitEnergy(unitEnergy + pt);
-
-         // Pt cut flag
-         if(uArray->GetUnitEnergy()<ptMin){
-           uArray->SetUnitCutFlag(kPtSmaller);
-         }
-         else {
-           uArray->SetUnitCutFlag(kPtHigher);
-           if(ok) nTracksTpcOnlyCut++;
-         }
-
-         // Signal flag
-         if(sflag[goodTrack] == 1) { 
-           uArray->SetUnitSignalFlag(kGood);
-            uArray->SetUnitSignalFlagC(kFALSE,kGood);
-          } else uArray->SetUnitSignalFlagC(kFALSE,kBad);
-
-         if(uArray->GetUnitEnergy()>0 && ref){
-           if(!fProcId) {
-             fProcId = kTRUE;
-             new(fRefArray) TRefArray(TProcessID::GetProcessWithUID(uArray));
-           }
-           fRefArray->Add(uArray);
-         }
-       }
-    
-      if(fGrid==1)
-       {
-
-         Int_t nElements = fTPCGrid->GetNEntries();
-         // Fill track information in EMCAL acceptance
-         if((eta >= fEtaMin && eta <= fEtaMax) &&
-            (phi >= fPhiMin && phi <= fPhiMax))// &&
-           {
-             // Include dead-zones
-             if(fDZ)
-               {
-                 Double_t phimin0 = 0., phimin1 = 0., phimin2 = 0., phimin3 = 0., phimin4 = 0.;
-                 Double_t phimax0 = 0., phimax1 = 0., phimax2 = 0., phimax3 = 0., phimax4 = 0.;
-                 fGeom->GetEMCGeometry()->GetPhiBoundariesOfSMGap(0,phimin0,phimax0);
-                 fGeom->GetEMCGeometry()->GetPhiBoundariesOfSMGap(1,phimin1,phimax1);
-                 fGeom->GetEMCGeometry()->GetPhiBoundariesOfSMGap(2,phimin2,phimax2);
-                 fGeom->GetEMCGeometry()->GetPhiBoundariesOfSMGap(3,phimin3,phimax3);
-                 fGeom->GetEMCGeometry()->GetPhiBoundariesOfSMGap(4,phimin4,phimax4);
-                 Int_t n0 = fGrid0->GetNEntries();
-                 Int_t n1 = fGrid1->GetNEntries();
-                 Int_t n2 = fGrid2->GetNEntries();
-                 Int_t n3 = fGrid3->GetNEntries();
-                 
-                 if(phi >= phimin0 && phi <= phimax0){
-                   Int_t id0 = fGrid0->GetIndex(phi,eta)-1;
-                   AliJetUnitArray *uArray0 = (AliJetUnitArray*)fUnitArray->At(id0+fNumUnits+nElements);
-                   TRefArray *reference0 = uArray0->GetUnitTrackRef();
-                   if (reference0->GetEntries() == 0) {
-                       new(reference0) TRefArray(TProcessID::GetProcessWithUID(track));
-                   }
-
-                   reference0->Add(track);
-                   uArray0->SetUnitTrackID(it);
-
-                   Float_t uEnergy0 = uArray0->GetUnitEnergy();
-                   Bool_t ok0 = kFALSE;
-                   Bool_t ref0 = kFALSE;
-                   if(uEnergy0==0.){
-                     nTracksEmcalDZ++;
-                     ok0 = kTRUE;
-                     ref0 = kTRUE;
-                   }
-                   uArray0->SetUnitEnergy(uEnergy0+pt);
-
-                   if(uArray0->GetUnitEnergy()<ptMin)
-                     uArray0->SetUnitCutFlag(kPtSmaller);
-                   else {
-                     uArray0->SetUnitCutFlag(kPtHigher);
-                     if(ok0) nTracksEmcalDZCut++;
-                   }
-                   if(sflag[goodTrack] == 1) {
-                     uArray0->SetUnitSignalFlag(kGood);
-                      uArray0->SetUnitSignalFlagC(kFALSE,kGood);
-                    } else uArray0->SetUnitSignalFlagC(kFALSE,kBad);
-
-                   if(uArray0->GetUnitEnergy()>0 && ref0){
-                     if(!fProcId){
-                       new(fRefArray) TRefArray(TProcessID::GetProcessWithUID(uArray0));
-                       fProcId = kTRUE;
-                     }
-                     fRefArray->Add(uArray0);
-                   }
-                 }
-
-                 if(phi >= phimin1 && phi <= phimax1){
-                   Int_t id1 = fGrid1->GetIndex(phi,eta)-1+n0;
-                   AliJetUnitArray *uArray1 = (AliJetUnitArray*)fUnitArray->At(id1+fNumUnits+nElements);
-                   TRefArray *reference1 = uArray1->GetUnitTrackRef();
-                   if (reference1->GetEntries() == 0) {
-                       new(reference1) TRefArray(TProcessID::GetProcessWithUID(track));
-                   }
-
-                   reference1->Add(track);
-
-                   Float_t uEnergy1 = uArray1->GetUnitEnergy();
-                   Bool_t ok1 = kFALSE;
-                   Bool_t ref1 = kFALSE;
-                   if(uEnergy1==0.){
-                     nTracksEmcalDZ++;
-                     ok1 = kTRUE;
-                     ref1 = kTRUE;
-                   }
-                   uArray1->SetUnitEnergy(uEnergy1+pt);
-
-                   if(uArray1->GetUnitEnergy()<ptMin)
-                     uArray1->SetUnitCutFlag(kPtSmaller);
-                   else {
-                     uArray1->SetUnitCutFlag(kPtHigher);
-                     if(ok1) nTracksEmcalDZCut++;
-                   }
-                   if(sflag[goodTrack] == 1) {
-                     uArray1->SetUnitSignalFlag(kGood);
-                      uArray1->SetUnitSignalFlagC(kFALSE,kGood);
-                    } else uArray1->SetUnitSignalFlagC(kFALSE,kBad);
-
-                   if(uArray1->GetUnitEnergy()>0 && ref1){
-                     if(!fProcId){
-                       new(fRefArray) TRefArray(TProcessID::GetProcessWithUID(uArray1));
-                       fProcId = kTRUE;
-                     }
-                     fRefArray->Add(uArray1);
-                   }
-                 }
-
-                 if(phi >= phimin2 && phi <= phimax2){
-                   Int_t id2 = fGrid2->GetIndex(phi,eta)-1+n0+n1;
-                   AliJetUnitArray *uArray2 = (AliJetUnitArray*)fUnitArray->At(id2+fNumUnits+nElements);
-                   TRefArray *reference2 = uArray2->GetUnitTrackRef();
-                   if (reference2->GetEntries() == 0) {
-                       new(reference2) TRefArray(TProcessID::GetProcessWithUID(track));
-                   }
-
-                   reference2->Add(track);
-
-                   Float_t uEnergy2 = uArray2->GetUnitEnergy();
-                   Bool_t ok2 = kFALSE;
-                   Bool_t ref2 = kFALSE;
-                   if(uEnergy2==0.){
-                     nTracksEmcalDZ++;
-                     ok2 = kTRUE;
-                     ref2 = kTRUE;
-                   }
-                   uArray2->SetUnitEnergy(uEnergy2+pt);
-
-                   if(uArray2->GetUnitEnergy()<ptMin)
-                     uArray2->SetUnitCutFlag(kPtSmaller);
-                   else {
-                     uArray2->SetUnitCutFlag(kPtHigher);
-                     if(ok2) nTracksEmcalDZCut++;
-                   }
-                   if(sflag[goodTrack] == 1) {
-                     uArray2->SetUnitSignalFlag(kGood);
-                      uArray2->SetUnitSignalFlagC(kFALSE,kGood);
-                    } else uArray2->SetUnitSignalFlagC(kFALSE,kBad);
-
-                   if(uArray2->GetUnitEnergy()>0 && ref2){
-                     if(!fProcId){
-                       new(fRefArray) TRefArray(TProcessID::GetProcessWithUID(uArray2));
-                       fProcId = kTRUE;
-                     }
-                     fRefArray->Add(uArray2);
-                   }
-                 }
-
-                 if(phi >= phimin3 && phi <= phimax3){
-                   Int_t id3 = fGrid3->GetIndex(phi,eta)-1+n0+n1+n2;
-                   AliJetUnitArray *uArray3 = (AliJetUnitArray*)fUnitArray->At(id3+fNumUnits+nElements);
-                   TRefArray *reference3 = uArray3->GetUnitTrackRef();
-                   if (reference3->GetEntries() == 0) {
-                       new(reference3) TRefArray(TProcessID::GetProcessWithUID(track));
-                   }
-
-                   reference3->Add(track);
-
-                   Float_t uEnergy3 = uArray3->GetUnitEnergy();
-                   Bool_t ok3 = kFALSE;
-                   Bool_t ref3 = kFALSE;
-                   if(uEnergy3==0.){
-                     nTracksEmcalDZ++;
-                     ok3 = kTRUE;
-                     ref3 = kTRUE;
-                   }
-                   uArray3->SetUnitEnergy(uEnergy3+pt);
-
-                   if(uArray3->GetUnitEnergy()<ptMin)
-                     uArray3->SetUnitCutFlag(kPtSmaller);
-                   else {
-                     uArray3->SetUnitCutFlag(kPtHigher);
-                     if(ok3) nTracksEmcalDZCut++;
-                   }
-                   if(sflag[goodTrack] == 1) {
-                     uArray3->SetUnitSignalFlag(kGood);
-                      uArray3->SetUnitSignalFlagC(kFALSE,kGood);
-                    } else uArray3->SetUnitSignalFlagC(kFALSE,kBad);
-
-                   if(uArray3->GetUnitEnergy()>0 && ref3){
-                     if(!fProcId){
-                       new(fRefArray) TRefArray(TProcessID::GetProcessWithUID(uArray3));
-                       fProcId = kTRUE;
-                     }
-                     fRefArray->Add(uArray3);
-                   }
-                 }
-
-                 if(phi >= phimin4 && phi <= phimax4){
-                   Int_t id4 = fGrid4->GetIndex(phi,eta)-1+n0+n1+n2+n3;
-                   AliJetUnitArray *uArray4 = (AliJetUnitArray*)fUnitArray->At(id4+fNumUnits+nElements);
-                   TRefArray *reference4 = uArray4->GetUnitTrackRef();
-                   if (reference4->GetEntries() == 0) {
-                       new(reference4) TRefArray(TProcessID::GetProcessWithUID(track));
-                   }
-
-                   reference4->Add(track);
-
-                   Float_t uEnergy4 = uArray4->GetUnitEnergy();
-                   Bool_t ok4 = kFALSE;
-                   Bool_t ref4 = kFALSE;
-                   if(uEnergy4==0.){
-                     nTracksEmcalDZ++;
-                     ok4 = kTRUE;
-                     ref4 = kTRUE;
-                   }
-                   uArray4->SetUnitEnergy(uEnergy4+pt);
-
-                   if(uArray4->GetUnitEnergy()<ptMin)
-                     uArray4->SetUnitCutFlag(kPtSmaller);
-                   else {
-                     uArray4->SetUnitCutFlag(kPtHigher);
-                     if(ok4) nTracksEmcalDZCut++;
-                   }
-                   if(sflag[goodTrack] == 1) {
-                     uArray4->SetUnitSignalFlag(kGood);
-                      uArray4->SetUnitSignalFlagC(kFALSE,kGood);
-                    } else uArray4->SetUnitSignalFlagC(kFALSE,kBad);
-
-                   if(uArray4->GetUnitEnergy()>0 && ref4){
-                     if(!fProcId){
-                       new(fRefArray) TRefArray(TProcessID::GetProcessWithUID(uArray4));
-                       fProcId = kTRUE;
-                     }
-                     fRefArray->Add(uArray4);
-                   }
-                 }
-               } // end fDZ
-           
-             Int_t towerID = 0;
-             fGeom->GetAbsCellIdFromEtaPhi(eta,phi,towerID);
-             if(towerID==-1) continue;
-             
-             AliJetUnitArray *uArray = (AliJetUnitArray*)fUnitArray->At(towerID);
-             TRefArray *reference = uArray->GetUnitTrackRef();
-             if (reference->GetEntries() == 0) {
-                 new(reference) TRefArray(TProcessID::GetProcessWithUID(track));
-             }
-
-             reference->Add(track);
-
-             Float_t unitEnergy = uArray->GetUnitEnergy(); 
-             Bool_t ok = kFALSE;
-             Bool_t ref = kFALSE;
-             if(unitEnergy==0.){
-               nTracksEmcal++;
-               ok=kTRUE;
-               ref=kTRUE;
-             }
-
-             // Do Hadron Correction
-             // For the moment I apply MIP correction if p >= 0.5 GeV/c
-             // and only for tracks inside EMCal acceptance
-             // End of if(fGrid==1) -> hadron correction for all tracks
-// Temporarily commented - will be updated removing the AliAODpid dependence
-/*
-             if (fApplyMIPCorrection != 0 && p3.Mag() >= 0.5) 
-               {
-                 ((AliJetHadronCorrectionv1*)fHadCorr)->SetGeometry("EMCAL_COMPLETEV1",1.);
-
-                 Double_t etaOut = 0.;
-                 Double_t phiOut = 0.;
-                 ((AliJetHadronCorrectionv1*)fHadCorr)->TrackPositionEMCal(track,etaOut,phiOut);
-
-                 // One has to make sure that the track hits the calorimeter
-                 // We can then correct on average for these particles
-                 if((etaOut >= fEtaMin && etaOut <= fEtaMax) &&
-                    (phiOut >= fPhiMin && phiOut <= fPhiMax))// &&
-                   {
-                     Double_t   hCEnergy = (Double_t)fHadCorr->GetEnergy(p3.Mag(), (Double_t)eta,0);
-                     unitEnergy -= hCEnergy*TMath::Sin(2.0*TMath::ATan(TMath::Exp(-eta)));
-                   } 
-               } //end Hadron Correction loop
-*/
-
-             if((unitEnergy + pt) > 0.) uArray->SetUnitEnergy(unitEnergy + pt);
-             else uArray->SetUnitEnergy(0.);
-
-             // Put a pt cut flag
-             if(uArray->GetUnitEnergy()<ptMin){
-               uArray->SetUnitCutFlag(kPtSmaller);
-             }
-             else {
-               uArray->SetUnitCutFlag(kPtHigher);
-               if(ok) nTracksEmcalCut++;
-             }
-
-             // Signal flag
-             if(sflag[goodTrack] == 1) { 
-               uArray->SetUnitSignalFlag(kGood);
-                uArray->SetUnitSignalFlagC(kFALSE,kGood);
-              } else uArray->SetUnitSignalFlagC(kFALSE,kBad);
-
-             if(uArray->GetUnitEnergy()>0 && ref){
-               if(!fProcId){
-                 new(fRefArray) TRefArray(TProcessID::GetProcessWithUID(uArray));
-                 fProcId = kTRUE;
-               }
-               fRefArray->Add(uArray);
-             }
-           } // end loop on EMCal acceptance cut + tracks quality
-         else{ 
-           // Outside EMCal acceptance
-           //  Int_t idTPC = GetIndexFromEtaPhi(etaT[i],phiT[i]);
-           Int_t idTPC = fTPCGrid->GetIndex(phi,eta);
-
-           AliJetUnitArray *uArray = (AliJetUnitArray*)fUnitArray->At(fNumUnits-1+idTPC);
-           TRefArray *reference = uArray->GetUnitTrackRef();
-           if (reference->GetEntries() == 0) {
-               new(reference) TRefArray(TProcessID::GetProcessWithUID(track));
-           }
-           reference->Add(track);
-
-           Float_t unitEnergy2 = uArray->GetUnitEnergy(); // check if fNumUnits or fNumUnits-1
-           Bool_t okout = kFALSE;
-           Bool_t refout = kFALSE;
-           if(unitEnergy2==0.){
-             nTracksTpc++;
-             okout=kTRUE;
-             refout=kTRUE;
-           }
-           // Fill energy outside emcal acceptance
-           uArray->SetUnitEnergy(unitEnergy2 + pt);
-         
-           // Pt cut flag
-           if(uArray->GetUnitEnergy()<ptMin){
-             uArray->SetUnitCutFlag(kPtSmaller);
-           }
-           else {
-             uArray->SetUnitCutFlag(kPtHigher);
-             if(okout) nTracksTpcCut++;
-           }
-           // Signal flag
-           if(sflag[goodTrack] == 1) {
-             uArray->SetUnitSignalFlag(kGood);
-              uArray->SetUnitSignalFlagC(kFALSE,kGood);
-            } else uArray->SetUnitSignalFlagC(kFALSE,kBad);
-
-           if(uArray->GetUnitEnergy()>0 && refout){
-             if(!fProcId){
-               new(fRefArray) TRefArray(TProcessID::GetProcessWithUID(uArray));
-               fProcId = kTRUE;
-             }
-             fRefArray->Add(uArray);
-           }
-         }
-
-         /*
-         // Do hadron correction
-          // In principle, the best thing to do as particles which
-          // eta,phi (at vertex) correspond to EMCal dead zone can deposit energy
-          // in the calorimeter as well as particles with eta,phi (at vertex)
-          // outside the EMCal acceptance
-         cout << "Hadronic correction for all tracks goes here" << endl;
-         
-         // For the moment I apply MIP correction if p >= 0.5 GeV/c
-         if (fApplyMIPCorrection != 0 && p3.Mag() >= 0.5) 
-           { 
-             ((AliJetHadronCorrectionv1*)fHadCorr)->SetGeometry("EMCAL_COMPLETEV1",1.);
-             
-             Double_t etaOut = 0.;
-             Double_t phiOut = 0.;
-             Int_t towerID2 = 0;
-             Float_t unitEnergy = 0.;
-             ((AliJetHadronCorrectionv1*)fHadCorr)->TrackPositionEMCal(track,etaOut,phiOut);
-             
-             // One has to make sure that the track hits the calorimeter
-             // We can then correct on average for these particles
-             if((etaOut >= fEtaMin && etaOut <= fEtaMax) &&
-                (phiOut >= fPhiMin && phiOut <= fPhiMax))// &&
-               {
-                 Int_t towerID = 0;
-                 Int_t towerID2 = 0;
-                 fGeom->GetAbsCellIdFromEtaPhi(etaOut,phiOut,towerID2);
-                 if(towerID2==-1) continue;
-                 
-                 AliJetUnitArray *uArray = (AliJetUnitArray*)fUnitArray->At(towerID2);
-                 unitEnergy = uArray->GetUnitEnergy(); 
-                 Bool_t ok = kFALSE;
-                 Bool_t ref = kFALSE;
-                 if(unitEnergy==0.){
-                   nTracksEmcal++;
-                   ok=kTRUE;
-                   ref=kTRUE;
-                 }
-                 
-                 Double_t   hCEnergy = (Double_t)fHadCorr->GetEnergy(p3.Mag(), (Double_t)eta,0);
-                 unitEnergy -= hCEnergy*TMath::Sin(2.0*TMath::ATan(TMath::Exp(-eta)));
-                 
-                 // The energy in this unitarray can be negative
-                 // If the Digits are then filled, make sure the energy sum
-                 // is positive. If not, put the value to zero in AliJetAODUnitArrayEMCalDigit.
-                 // If they are not filled, put this value to zero
-                 uArray->SetUnitEnergy(unitEnergy);
-                 
-                 if(uArray->GetUnitEnergy()!=0. && ref){
-                   if(!fProcId){
-                     new(fRefArray) TRefArray(TProcessID::GetProcessWithUID(uArray));
-                     fProcId = kTRUE;
-                   }
-                   fRefArray->Add(uArray);
-                 }
-               }
-             else cout << "Track out of EMCal acceptance" << endl; 
-             
-           } //end Hadron Correction loop
-         */
-         
-       } // end fGrid==1
-
-      goodTrack++;
-
-    } // end loop on entries (tpc tracks)
-
-
-  if(fDebug>0)
-    {
-      cout << "End of Tracks %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%" << endl;
-      cout << "goodTracks: " << goodTrack << endl;
-    }
-
-  fSignalFlag.Set(goodTrack,sflag);
-  fCutFlag.Set(goodTrack,cflag);
-
-  delete[] sflag;
-  delete[] cflag;
-
-  //    } // end loop on entries (tpc tracks)
-      
-  if(fGrid==0) {
-    fNTracks = nTracksTpcOnly;
-    fNTracksCut = nTracksTpcOnlyCut;
-    if(fDebug>10){
-      cout << "fNTracks : " << fNTracks << endl;
-      cout << "fNTracksCut : " << fNTracksCut << endl;
-    }
-  }
-  if(fGrid==1) {
-    fNTracks = nTracksEmcal+nTracksEmcalDZ+nTracksTpc;
-    fNTracksCut = nTracksEmcalCut+nTracksEmcalDZCut+nTracksTpcCut;
-    if(fDebug>10){
-      cout << "fNTracks : " << fNTracks << endl;
-      cout << "fNTracksCut : " << fNTracksCut << endl;
-    }
-  }  
-  
-}
-
diff --git a/JETAN/AliJetAODFillUnitArrayTracks.h b/JETAN/AliJetAODFillUnitArrayTracks.h
deleted file mode 100644 (file)
index 8060977..0000000
+++ /dev/null
@@ -1,64 +0,0 @@
-#ifndef ALIJETAODFILLUNITARRAYTRACKS_H
-#define ALIJETAODFILLUNITARRAYTRACKS_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-//---------------------------------------------------------------------
-// Jet Fill Unit Array 
-// Called by ESD Reader for jet analysis
-// Author: Magali Estienne (magali.estienne@subatech.in2p3.fr)
-//---------------------------------------------------------------------
-
-#include "AliJetFillUnitArray.h"
-
-class AliJetReader;
-class AliJetAODReader;
-class AliEMCALGeometry;
-
-class AliJetAODFillUnitArrayTracks : public AliJetFillUnitArray
-{
- public: 
-  AliJetAODFillUnitArrayTracks();
-  AliJetAODFillUnitArrayTracks(AliAODEvent *fAOD);
-  virtual ~AliJetAODFillUnitArrayTracks();
-  
-  // Setter
-  void SetHadCorrector(AliJetHadronCorrection* const corr) {fHadCorr = corr;}
-  void SetApplyMIPCorrection(Bool_t const val)             {fApplyMIPCorrection = val;}
-  void SetAOD(AliAODEvent* const aod)                      {fAOD = aod;}
-  void SetGrid0(AliJetGrid* const grid0)                   {fGrid0 = grid0;}
-  void SetGrid1(AliJetGrid* const grid1)                   {fGrid1 = grid1;}
-  void SetGrid2(AliJetGrid* const grid2)                   {fGrid2 = grid2;}
-  void SetGrid3(AliJetGrid* const grid3)                   {fGrid3 = grid3;}
-  void SetGrid4(AliJetGrid* const grid4)                   {fGrid4 = grid4;}
-
-  // Getter
-  Int_t GetHadCorrection()  const {return fApplyMIPCorrection;}
-  Int_t GetMult()           const {return fNTracks;}
-  Int_t GetMultCut()        const {return fNTracksCut;}
-
-  // Other
-  void Exec(Option_t* const option);
-
- protected:
-  Int_t                     fNumUnits;           // Number of units in the unit object array (same as num towers in EMCAL)
-  AliJetHadronCorrection   *fHadCorr;            // Pointer to Hadron Correction Object
-  Bool_t                    fApplyMIPCorrection; // Apply MIP or not ? Exclusive with fApplyFractionHadronicCorrection
-
-  AliAODEvent              *fAOD;                // AOD output Event
-  AliJetGrid               *fGrid0;              // Grid used for dead zones definition
-  AliJetGrid               *fGrid1;              // Grid used for dead zones definition
-  AliJetGrid               *fGrid2;              // Grid used for dead zones definition
-  AliJetGrid               *fGrid3;              // Grid used for dead zones definition
-  AliJetGrid               *fGrid4;              // Grid used for dead zones definition
-
- private:
-  AliJetAODFillUnitArrayTracks(const AliJetAODFillUnitArrayTracks &det);
-  AliJetAODFillUnitArrayTracks &operator=(const AliJetAODFillUnitArrayTracks &det);
-  void InitParameters();
-
-  ClassDef(AliJetAODFillUnitArrayTracks,1) // Fill Unit Array with tpc and/or emcal information
-};
-
-#endif
diff --git a/JETAN/AliJetAODReader.cxx b/JETAN/AliJetAODReader.cxx
deleted file mode 100644 (file)
index 2bdf759..0000000
+++ /dev/null
@@ -1,739 +0,0 @@
-/**************************************************************************
- * 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.                  *
- **************************************************************************/
-
-//------------------------------------------------------------------------- 
-// Jet AOD Reader 
-// AOD reader for jet analysis
-// This is the reader which must be used if the jet analysis task
-// is executed after the ESD filter task, in order to read its output
-//
-// Author: Davide Perrino <davide.perrino@cern.ch>
-//
-// **February 2011
-// implemented standard geometry (AliEMCALGeometry) instead of dummy one (AliJetDummyGeo)
-// moved geometry definition in AliJetReader
-// marco.bregant@subatech.in2p3.fr
-//------------------------------------------------------------------------- 
-
-
-#include <Riostream.h>
-#include <TSystem.h>
-#include <TLorentzVector.h>
-#include <TVector3.h>
-#include <TChain.h>
-#include <TFile.h>
-#include <TTask.h>
-#include <TGeoManager.h>
-#include <TGeoMatrix.h>
-
-#include "AliJetAODReader.h"
-#include "AliJetAODReaderHeader.h"
-#include "AliAODEvent.h"
-#include "AliAODTrack.h"
-#include "AliAODMCParticle.h"
-#include "AliEMCALGeometry.h"
-#include "AliJetAODFillUnitArrayTracks.h"
-#include "AliJetAODFillUnitArrayEMCalDigits.h"
-#include "AliJetHadronCorrectionv1.h"
-#include "AliJetUnitArray.h"
-#include "AliOADBContainer.h"
-
-using std::cout;
-using std::endl;
-ClassImp(AliJetAODReader)
-
-AliJetAODReader::AliJetAODReader():
-    AliJetReader(),
-    fAOD(0x0),
-    fRef(new TRefArray),
-    fDebug(0),
-    fOpt(0),
-    fHadCorr(0x0),
-    fTpcGrid(0x0),
-    fEmcalGrid(0x0),
-    fGrid0(0),
-    fGrid1(0),
-    fGrid2(0),
-    fGrid3(0),
-    fGrid4(0),
-    fApplyElectronCorrection(kFALSE),
-    fApplyMIPCorrection(kTRUE),
-    fApplyFractionHadronicCorrection(kFALSE),
-    fFractionHadronicCorrection(0.3),
-    fNumUnits(0),
-    fMass(0),
-    fSign(0),
-    fNIn(0),
-    fDZ(0),
-    fNeta(0),
-    fNphi(0),
-    fRefArray(0x0),
-    fProcId(kFALSE)
-{
-  // Constructor    
-}
-
-//____________________________________________________________________________
-
-AliJetAODReader::~AliJetAODReader()
-{
-  // Destructor
-    delete fAOD;
-    delete fRef;
-    delete fTpcGrid;
-    delete fEmcalGrid;
-    if(fDZ)
-      {
-        delete fGrid0;
-        delete fGrid1;
-        delete fGrid2;
-        delete fGrid3;
-        delete fGrid4;
-      }
-
-}
-
-//____________________________________________________________________________
-
-void AliJetAODReader::OpenInputFiles()
-{
-    // Open the necessary input files
-    // chain for the AODs
-  fChain   = new TChain("aodTree");
-
-  // get directory and pattern name from the header
-   const char* dirName=fReaderHeader->GetDirectory();
-   const char* pattern=fReaderHeader->GetPattern();
-
-//   // Add files matching patters to the chain
-
-   void *dir  = gSystem->OpenDirectory(dirName);
-   const char *name = 0x0;
-   int naod = ((AliJetAODReaderHeader*) fReaderHeader)->GetNaod();
-   int a = 0;
-   while ((name = gSystem->GetDirEntry(dir))){
-       if (a>=naod) continue;
-       
-       if (strstr(name,pattern)){
-          fChain->AddFile(Form("%s/%s/aod.root",dirName,name));
-          a++;
-       }
-   }
-  
-  gSystem->FreeDirectory(dir);
-  
-  fAOD = 0;
-  fChain->SetBranchAddress("AOD",&fAOD);
-  
-  int nMax = fChain->GetEntries(); 
-
-  printf("\n AliJetAODReader: Total number of events in chain= %d \n",nMax);
-  
-  // set number of events in header
-  if (fReaderHeader->GetLastEvent() == -1)
-    fReaderHeader->SetLastEvent(nMax);
-  else {
-    Int_t nUsr = fReaderHeader->GetLastEvent();
-    fReaderHeader->SetLastEvent(TMath::Min(nMax,nUsr));
-  }
-}
-
-//____________________________________________________________________________
-
-void AliJetAODReader::ConnectTree(TTree* tree, TObject* /*data*/) {
-    // Connect the tree
-    // For AOD reader it's needed only to set the number of events
-     fChain = (TChain*)      tree;
-     
-     Int_t nMax = fChain->GetEntries(); 
-     printf("\n AliJetAODReader: Total number of events in chain= %5d \n", nMax);
-     // set number of events in header
-     if (fReaderHeader->GetLastEvent() == -1)
-        fReaderHeader->SetLastEvent(nMax);
-     else {
-        Int_t nUsr = fReaderHeader->GetLastEvent();
-        fReaderHeader->SetLastEvent(TMath::Min(nMax,nUsr));
-     }
-}
-
-
-Bool_t AliJetAODReader::AcceptAODMCParticle(AliAODMCParticle *mcP,Short_t flag){
-
-  //
-  // filter for charge and for charged and neutral, no detector
-  // response yet
-  // physical priamries already selected
-
-  Int_t   pdg     = TMath::Abs(mcP->GetPdgCode());
-
-  // exclude neutrinos anyway   
-  if((pdg == 12 || pdg == 14 || pdg == 16)) return kFALSE;
-
-  if(flag==AliJetAODReaderHeader::kAllMC)return kTRUE;
-  if(flag==AliJetAODReaderHeader::kChargedMC){
-    if(mcP->Charge()==0)return kFALSE;
-    return kTRUE;
-  }
-
-  return kTRUE;
-
-}
-
-Bool_t AliJetAODReader::FillMomentumArrayMC(){
-
-  // 
-  // This routine fetches the MC particles from the AOD
-  // Depending on the flag all particles except neurinos are use
-  // or only charged particles
-  //
-
-  TClonesArray *mcArray = (TClonesArray*)fAOD->FindListObject(AliAODMCParticle::StdBranchName());
-  if(!mcArray){
-    Printf("%s:%d No MC particle branch found",(char*)__FILE__,__LINE__);
-    return kFALSE;
-  }
-  
-  Int_t nMC = mcArray->GetEntriesFast();
-  
-  // get number of tracks in event (for the loop)
-  if(fDebug>0)printf("AOD MC tracks: %5d \t", nMC);
-  
-  // temporary storage of signal and pt cut flag
-  Int_t* sflag  = new Int_t[nMC];
-  Int_t* cflag  = new Int_t[nMC];
-  
-  // get cuts set by user
-  Float_t ptMin =  fReaderHeader->GetPtCut();
-  Float_t etaMin = fReaderHeader->GetFiducialEtaMin();
-  Float_t etaMax = fReaderHeader->GetFiducialEtaMax();  
-  Int_t mcTrack = 0;
-  Float_t pt, eta;
-  TVector3 p3;
-
-  Short_t readerFlag = ((AliJetAODReaderHeader*)fReaderHeader)->GetReadAODMC();
-
-
-  for (Int_t it = 0; it < nMC; it++) {
-    AliAODMCParticle *track = (AliAODMCParticle*)mcArray->At(it);
-    if(!track->IsPhysicalPrimary())continue;
-
-    p3.SetXYZ(track->Px(),track->Py(),track->Pz());
-    eta = p3.Eta();
-    if ( (eta > etaMax) || (eta < etaMin)) continue;      // checking eta cut
-    if(!AcceptAODMCParticle(track,readerFlag))continue;
-    pt = p3.Pt();
-
-
-    
-
-    if (mcTrack == 0){
-      fRef->Delete(); // make sure to delete before placement new...
-      new(fRef) TRefArray(TProcessID::GetProcessWithUID(track));
-    }
-    new ((*fMomentumArray)[mcTrack]) TLorentzVector(p3,p3.Mag());
-    sflag[mcTrack] = 1;
-    cflag[mcTrack] = ( pt > ptMin ) ? 1: 0;
-    fRef->Add(track);
-    mcTrack++;
-  }
-  if(fDebug>0)printf("Used MC tracks: %5d \n", mcTrack);
-  // set the signal flags
-  fSignalFlag.Set(mcTrack,sflag);
-  fCutFlag.Set(mcTrack,cflag);
-
-  delete [] sflag;
-  delete [] cflag;
-
-  return kTRUE;
-}
-
-//____________________________________________________________________________
-
-Bool_t AliJetAODReader::FillMomentumArray()
-{
-  // Clear momentum array
-  ClearArray();
-  fRef->Clear();
-  fDebug = fReaderHeader->GetDebug();
-
-  if (!fAOD) {
-      return kFALSE;
-  }
-
-  // get cuts set by user
-  Float_t ptMin =  fReaderHeader->GetPtCut();
-  Float_t etaMin = fReaderHeader->GetFiducialEtaMin();
-  Float_t etaMax = fReaderHeader->GetFiducialEtaMax();  
-  UInt_t  filterMask =  ((AliJetAODReaderHeader*)fReaderHeader)->GetTestFilterMask();
-
-  // ----- number of tracks -----
-  Int_t nTracksStd    = 0;
-  Short_t mcReaderFlag = ((AliJetAODReaderHeader*)fReaderHeader)->GetReadAODMC();
-  TClonesArray *mcArray = 0x0;
-  // check if we have to read from MC branch
-  if (((AliJetAODReaderHeader*)fReaderHeader)->GetReadStdBranch()) {
-    if(mcReaderFlag) {
-      mcArray = (TClonesArray*)fAOD->FindListObject(AliAODMCParticle::StdBranchName());
-      if(!mcArray){
-       Printf("%s:%d No MC particle branch found",(char*)__FILE__,__LINE__);
-      }
-      nTracksStd = mcArray->GetEntriesFast();
-    }
-    else {
-      nTracksStd = fAOD->GetNTracks();
-      //      printf("no. of standard tracks: %i\n", nTracksStd);
-    }
-  }
-  Int_t nTracksNonStd = 0;
-  TClonesArray *nonStdTracks = 0x0;
-  if (((AliJetAODReaderHeader*)fReaderHeader)->GetReadNonStdBranch()) {
-    nonStdTracks =
-      (TClonesArray*) fAOD->FindListObject(((AliJetAODReaderHeader*)fReaderHeader)->GetNonStdBranch());
-    if (nonStdTracks)
-      nTracksNonStd = nonStdTracks->GetEntries();
-    //    printf("no. of non-standard tracks: %i\n", nTracksNonStd);
-  }
-  Int_t nTracks = nTracksStd + nTracksNonStd;
-
-  // temporary storage of signal and pt cut flag
-  Int_t* sflag  = new Int_t[nTracks];
-  Int_t* cflag  = new Int_t[nTracks];
-
-  // loop over tracks
-  Int_t aodTrack = 0;
-  Float_t pt, eta;
-  TVector3 p3;
-
-  // ----- looping over standard branch -----
-  if (mcArray) {
-    for (Int_t iTrack = 0; iTrack < nTracksStd; iTrack++) {
-      AliAODMCParticle *track = (AliAODMCParticle*)mcArray->At(iTrack);
-      if(!track->IsPhysicalPrimary())continue;
-
-      p3.SetXYZ(track->Px(),track->Py(),track->Pz());
-      eta = p3.Eta();
-      if ( (eta > etaMax) || (eta < etaMin)) continue;      // checking eta cut
-      if(!AcceptAODMCParticle(track,mcReaderFlag))continue;
-      pt = p3.Pt();
-
-      if (aodTrack == 0){
-       fRef->Delete(); // make sure to delete before placement new...
-       new(fRef) TRefArray(TProcessID::GetProcessWithUID(track));
-      }
-      new ((*fMomentumArray)[aodTrack]) TLorentzVector(p3,p3.Mag());
-      sflag[aodTrack] = 1;
-      cflag[aodTrack] = ( pt > ptMin ) ? 1: 0;
-      fRef->Add(track);
-      aodTrack++;
-    }
-  }
-  else {
-    for (Int_t iTrack = 0; iTrack < nTracksStd; iTrack++) {
-      AliAODTrack *track = fAOD->GetTrack(iTrack);
-      UInt_t status = track->GetStatus();
-
-      Double_t mom[3] = {track->Px(),track->Py(),track->Pz()};
-      p3.SetXYZ(mom[0],mom[1],mom[2]);
-      pt = p3.Pt();
-      eta = p3.Eta();
-      if (status == 0) continue;
-      if((filterMask>0)&&!(track->TestFilterBit(filterMask)))continue;
-      if ( (eta > etaMax) || (eta < etaMin)) continue;      // checking eta cut
-
-      if (aodTrack == 0){
-       fRef->Delete(); // make sure to delete before placement new...
-       new(fRef) TRefArray(TProcessID::GetProcessWithUID(track));
-      }
-      new ((*fMomentumArray)[aodTrack]) TLorentzVector(p3,p3.Mag());
-      sflag[aodTrack] = (TMath::Abs(track->GetLabel()) < 10000) ? 1 : 0;
-      cflag[aodTrack] = ( pt > ptMin ) ? 1: 0;
-      aodTrack++;
-      fRef->Add(track);
-    }
-  }
-
-  // ----- reading of non-standard branch -----
-  for (Int_t iTrack = 0; iTrack < nTracksNonStd; iTrack++) {
-    AliVParticle *track = dynamic_cast<AliVParticle*> ((*nonStdTracks)[iTrack]);
-    if (!track)
-      continue;
-
-    Double_t mom[3] = {track->Px(),track->Py(),track->Pz()};
-    p3.SetXYZ(mom[0],mom[1],mom[2]);
-    pt = p3.Pt();
-    eta = p3.Eta();
-
-    // which cuts to apply if not AOD track (e.g. MC) ???
-    AliAODTrack *trackAOD = dynamic_cast<AliAODTrack*> (track);
-    if (trackAOD) {
-      if (trackAOD->GetStatus() == 0)
-       continue;
-      if ((filterMask > 0) && !(trackAOD->TestFilterBit(filterMask)))
-       continue;
-    }
-    if ((eta > etaMax) || (eta < etaMin)) continue;      // checking eta cut
-
-    if (aodTrack == 0){
-      fRef->Delete(); // make sure to delete before placement new...
-      new(fRef) TRefArray(TProcessID::GetProcessWithUID(track));
-    }
-    new ((*fMomentumArray)[aodTrack]) TLorentzVector(p3,p3.Mag());
-    sflag[aodTrack] = (TMath::Abs(track->GetLabel()) < 10000) ? 1 : 0;
-    cflag[aodTrack] = ( pt > ptMin ) ? 1 : 0;
-    aodTrack++;
-    fRef->Add(track);
-    //    printf("added non-standard track\n");
-  }
-
-  // set the signal flags
-  fSignalFlag.Set(aodTrack,sflag);
-  fCutFlag.Set(aodTrack,cflag);
-
-  delete [] sflag;
-  delete [] cflag;
-
-  return kTRUE;
-}
-
-//__________________________________________________________
-void AliJetAODReader::SetApplyMIPCorrection(Bool_t val)
-{
-  //
-  // Set flag to apply MIP correction fApplyMIPCorrection
-  // - exclusive with fApplyFractionHadronicCorrection
-  //
-
-  fApplyMIPCorrection = val;
-  if(fApplyMIPCorrection == kTRUE)
-    {
-      SetApplyFractionHadronicCorrection(kFALSE);
-      printf("Enabling MIP Correction \n");
-    }
-  else
-    {
-      printf("Disabling MIP Correction \n");
-    }
-}
-
-//__________________________________________________________
-void AliJetAODReader::SetApplyFractionHadronicCorrection(Bool_t val)
-{
-  //
-  // Set flag to apply EMC hadronic correction fApplyFractionHadronicCorrection
-  // - exclusive with fApplyMIPCorrection
-  //
-
-  fApplyFractionHadronicCorrection = val;
-  if(fApplyFractionHadronicCorrection == kTRUE)
-    {
-      SetApplyMIPCorrection(kFALSE);
-      printf("Enabling Fraction Hadronic Correction \n");
-    }
-  else
-    {
-      printf("Disabling Fraction Hadronic Correction \n");
-    }
-}
-
-//__________________________________________________________
-void AliJetAODReader::SetFractionHadronicCorrection(Double_t val)
-{
-  //
-  // Set value to fFractionHadronicCorrection (default is 0.3)
-  // apply EMC hadronic correction fApplyFractionHadronicCorrection
-  // - exclusive with fApplyMIPCorrection
-  //
-
-  fFractionHadronicCorrection = val;
-  if(fFractionHadronicCorrection > 0.0 && fFractionHadronicCorrection <= 1.0)
-    {
-      SetApplyFractionHadronicCorrection(kTRUE);
-      printf("Fraction Hadronic Correction %1.3f \n",fFractionHadronicCorrection);
-    }
-  else
-    {
-      SetApplyFractionHadronicCorrection(kFALSE);
-    }
-}
-
-//____________________________________________________________________________
-void AliJetAODReader::CreateTasks(TChain* tree)
-{
-  //
-  // For reader task initialization
-  //
-
-  fDebug = fReaderHeader->GetDebug();
-  fDZ = fReaderHeader->GetDZ();
-  fTree = tree;
-
-  // Init EMCAL geometry, if needed
-   if(fGeom == 0)
-         SetEMCALGeometry();
-       else Info(" SetEMCALGeometry","was already done.. it's called just once !!");
-  // Init parameters
-  InitParameters();
-  InitUnitArray();
-
-  fFillUnitArray = new TTask("fFillUnitArray","Fill unit array jet finder");
-  fFillUAFromTracks = new AliJetAODFillUnitArrayTracks();
-  fFillUAFromTracks->SetReaderHeader(fReaderHeader);
-  fFillUAFromTracks->SetGeom(fGeom);
-  fFillUAFromTracks->SetTPCGrid(fTpcGrid);
-  fFillUAFromTracks->SetEMCalGrid(fEmcalGrid);
-
-  if(fDZ)
-    {
-      fFillUAFromTracks->SetGrid0(fGrid0);
-      fFillUAFromTracks->SetGrid1(fGrid1);
-      fFillUAFromTracks->SetGrid2(fGrid2);
-      fFillUAFromTracks->SetGrid3(fGrid3);
-      fFillUAFromTracks->SetGrid4(fGrid4);
-    }
-  fFillUAFromTracks->SetApplyMIPCorrection(fApplyMIPCorrection);
-  fFillUAFromTracks->SetHadCorrector(fHadCorr);
-  fFillUAFromEMCalDigits = new AliJetAODFillUnitArrayEMCalDigits();
-  fFillUAFromEMCalDigits->SetReaderHeader(fReaderHeader);
-  fFillUAFromEMCalDigits->SetGeom(fGeom);
-  fFillUAFromEMCalDigits->SetTPCGrid(fTpcGrid);
-  fFillUAFromEMCalDigits->SetEMCalGrid(fEmcalGrid);
-  fFillUAFromEMCalDigits->SetApplyFractionHadronicCorrection(fApplyFractionHadronicCorrection);
-  fFillUAFromEMCalDigits->SetFractionHadronicCorrection(fFractionHadronicCorrection);
-  fFillUAFromEMCalDigits->SetApplyElectronCorrection(fApplyElectronCorrection);
-  // Add the task to global task
-  fFillUnitArray->Add(fFillUAFromTracks);
-  fFillUnitArray->Add(fFillUAFromEMCalDigits);
-  fFillUAFromTracks->SetActive(kFALSE);
-  fFillUAFromEMCalDigits->SetActive(kFALSE);
-
-  cout << "Tasks instantiated at that stage ! " << endl;
-  cout << "You can loop over events now ! " << endl;
-
-}
-
-//____________________________________________________________________________
-Bool_t AliJetAODReader::ExecTasks(Bool_t procid, TRefArray* refArray)
-{
-  //
-  // Main function
-  // Fill the reader part
-  //
-
-  fProcId = procid;
-  fRefArray = refArray;
-//(not used ?)  Int_t nEntRef = fRefArray->GetEntries();
-//(not used ?)  Int_t nEntUnit = fUnitArray->GetEntries();
-
-  // clear momentum array
-  ClearArray();
-  fRef->Clear();
-
-  fDebug = fReaderHeader->GetDebug();
-  fOpt = fReaderHeader->GetDetector();
-
-  if(!fAOD) {
-    return kFALSE;
-  }
-
-  // TPC only or Digits+TPC or Clusters+TPC
-  if(fOpt%2==!0 && fOpt!=0){
-    fFillUAFromTracks->SetAOD(fAOD);
-    fFillUAFromTracks->SetActive(kTRUE);
-    fFillUAFromTracks->SetUnitArray(fUnitArray);
-    fFillUAFromTracks->SetRefArray(fRefArray);
-    fFillUAFromTracks->SetReferences(fRef);
-    fFillUAFromTracks->SetSignalFlag(fSignalFlag);
-    fFillUAFromTracks->SetCutFlag(fCutFlag);
-    fFillUAFromTracks->SetProcId(fProcId);
-    //    fFillUAFromTracks->ExecuteTask("tpc"); // => Temporarily changed
-    fFillUAFromTracks->Exec("tpc");
-    if(fOpt==1){
-      fNumCandidate = fFillUAFromTracks->GetMult();
-      fNumCandidateCut = fFillUAFromTracks->GetMultCut();
-    }
-    fSignalFlag = fFillUAFromTracks->GetSignalFlag();
-    fCutFlag = fFillUAFromTracks->GetCutFlag();
-  }
-
-  // Digits only or Digits+TPC
-  if(fOpt>=2 && fOpt<=3){
-    fFillUAFromEMCalDigits->SetAOD(fAOD);
-    fFillUAFromEMCalDigits->SetActive(kTRUE);
-    fFillUAFromEMCalDigits->SetUnitArray(fUnitArray);
-    fFillUAFromEMCalDigits->SetRefArray(fRefArray);
-    fFillUAFromEMCalDigits->SetProcId(fFillUAFromTracks->GetProcId());
-    fFillUAFromEMCalDigits->SetInitMult(fFillUAFromTracks->GetMult());
-    fFillUAFromEMCalDigits->SetInitMultCut(fFillUAFromTracks->GetMultCut());
-    fFillUAFromEMCalDigits->Exec("digits"); // => Temporarily added
-    fNumCandidate = fFillUAFromEMCalDigits->GetMult();
-    fNumCandidateCut = fFillUAFromEMCalDigits->GetMultCut();
-  }
-
-  //  fFillUnitArray->ExecuteTask(); // => Temporarily commented
-
-  return kTRUE;
-}
-
-
-
-//____________________________________________________________________________
-void AliJetAODReader::InitParameters()
-{
-  // Initialise parameters
-  fOpt = fReaderHeader->GetDetector();
-  fNumUnits       = fGeom->GetEMCGeometry()->GetNCells();      // Number of cells in EMCAL
-  if(fDebug>1) printf("\n EMCal parameters initiated ! \n");
-}
-
-//____________________________________________________________________________
-void AliJetAODReader::InitUnitArray()
-{
-  //Initialises unit arrays
-  Int_t nElements = fTpcGrid->GetNEntries();
-  Float_t eta = 0., phi = 0., deltaEta = 0., deltaPhi = 0.;
-  if(fArrayInitialised) fUnitArray->Delete();
-
-  if(fTpcGrid->GetGridType()==0)
-    { // Fill the following quantities :
-      // Good track ID, (Eta,Phi) position ID, eta, phi, energy, px, py, pz, deltaEta, deltaPhi,
-      // detector flag, in/out jet, pt cut, mass, cluster ID)
-      for(Int_t nBin = 1; nBin < nElements+1; nBin++)
-        {
-          //      fTpcGrid->GetEtaPhiFromIndex2(nBin,eta,phi);
-          fTpcGrid->GetEtaPhiFromIndex2(nBin,phi,eta);
-          phi = ((phi < 0) ? phi + 2. * TMath::Pi() : phi);
-          deltaEta = fTpcGrid->GetDeta();
-          deltaPhi = fTpcGrid->GetDphi();
-          new ((*fUnitArray)[nBin-1]) AliJetUnitArray(nBin-1,0,eta,phi,0.,deltaEta,deltaPhi,kTpc,kOutJet,kPtSmaller,kPtSmaller,kBad,0.,-1);
-        }
-    }
-
-  if(fTpcGrid->GetGridType()==1)
-    {
-      Int_t nGaps = 0;
-      Int_t n0 = 0, n1 = 0, n2 = 0, n3 = 0, n4 = 0;
-
-      if(fDZ)
-        {
-          // Define a grid of cell for the gaps between SM
-          Double_t phimin0 = 0., phimin1 = 0., phimin2 = 0., phimin3 = 0., phimin4 = 0.;
-          Double_t phimax0 = 0., phimax1 = 0., phimax2 = 0., phimax3 = 0., phimax4 = 0.;
-          fGeom->GetEMCGeometry()->GetPhiBoundariesOfSMGap(0,phimin0,phimax0);
-          fGrid0 = new AliJetGrid(0,95,phimin0,phimax0,-0.7,0.7); // 0.015 x 0.015
-          fGrid0->SetGridType(0);
-          fGrid0->SetMatrixIndexes();
-          fGrid0->SetIndexIJ();
-          n0 = fGrid0->GetNEntries();
-          fGeom->GetEMCGeometry()->GetPhiBoundariesOfSMGap(1,phimin1,phimax1);
-          fGrid1 = new AliJetGrid(0,95,phimin1,phimax1,-0.7,0.7); // 0.015 x 0.015
-          fGrid1->SetGridType(0);
-          fGrid1->SetMatrixIndexes();
-          fGrid1->SetIndexIJ();
-          n1 = fGrid1->GetNEntries();
-          fGeom->GetEMCGeometry()->GetPhiBoundariesOfSMGap(2,phimin2,phimax2);
-          fGrid2 = new AliJetGrid(0,95,phimin2,phimax2,-0.7,0.7); // 0.015 x 0.015
-          fGrid2->SetGridType(0);
-          fGrid2->SetMatrixIndexes();
-          fGrid2->SetIndexIJ();
-          n2 = fGrid2->GetNEntries();
-          fGeom->GetEMCGeometry()->GetPhiBoundariesOfSMGap(3,phimin3,phimax3);
-          fGrid3 = new AliJetGrid(0,95,phimin3,phimax3,-0.7,0.7); // 0.015 x 0.015
-          fGrid3->SetGridType(0);
-          fGrid3->SetMatrixIndexes();
-          fGrid3->SetIndexIJ();
-          n3 = fGrid3->GetNEntries();
-          fGeom->GetEMCGeometry()->GetPhiBoundariesOfSMGap(4,phimin4,phimax4);
-          fGrid4 = new AliJetGrid(0,95,phimin4,phimax4,-0.7,0.7); // 0.015 x 0.015
-          fGrid4->SetGridType(0);
-          fGrid4->SetMatrixIndexes();
-          fGrid4->SetIndexIJ();
-          n4 = fGrid4->GetNEntries();
-
-          nGaps = n0+n1+n2+n3+n4;
-
-        }
-
-      for(Int_t nBin = 0; nBin < fNumUnits+nElements+nGaps; nBin++) 
-       {
-         if(nBin<fNumUnits)
-           {
-             fGeom->EtaPhiFromIndex(nBin, eta, phi); // From EMCal geometry 
-             // fEmcalGrid->GetEtaPhiFromIndex2(nBin,phi,eta); // My function from Grid
-             phi = ((phi < 0) ? phi + 2. * TMath::Pi() : phi);
-             deltaEta = fEmcalGrid->GetDeta(); // Modify with the exact detector values
-             deltaPhi = fEmcalGrid->GetDphi(); // Modify with the exact detector values
-             new ((*fUnitArray)[nBin]) AliJetUnitArray(nBin,0,eta,phi,0.,deltaEta,deltaPhi,kTpc,kOutJet,kPtSmaller,kPtSmaller,kBad,0.,-1);
-           } 
-         else {
-           if(nBin>=fNumUnits && nBin<fNumUnits+nElements){
-             fTpcGrid->GetEtaPhiFromIndex2(nBin+1-fNumUnits,phi,eta);
-             phi = ((phi < 0) ? phi + 2. * TMath::Pi() : phi);
-             deltaEta = fTpcGrid->GetDeta();
-             deltaPhi = fTpcGrid->GetDphi();
-             new ((*fUnitArray)[nBin]) AliJetUnitArray(nBin,0,eta,phi,0.,deltaEta,deltaPhi,kTpc,kOutJet,kPtSmaller,kPtSmaller,kBad,0.,-1);
-           }
-           else {
-             if(fDZ) {
-               if(nBin>=fNumUnits+nElements && nBin<fNumUnits+nElements+nGaps){
-                 if(nBin<fNumUnits+nElements+n0)
-                   {
-                     phi = eta = 0.;
-                     fGrid0->GetEtaPhiFromIndex2(nBin+1-(fNumUnits+nElements),phi,eta);
-                     deltaEta = fGrid0->GetDeta(); 
-                     deltaPhi = fGrid0->GetDphi(); 
-                     new ((*fUnitArray)[nBin]) AliJetUnitArray(nBin,0,eta,phi,0.,deltaEta,deltaPhi,kTpc,kOutJet,kPtSmaller,kPtSmaller,kBad,0.,-1);
-                   }
-                 else if(nBin>=fNumUnits+nElements+n0 && nBin<fNumUnits+nElements+n0+n1)
-                   {
-                     phi = eta = 0.;
-                     fGrid1->GetEtaPhiFromIndex2(nBin+1-(fNumUnits+nElements+n0),phi,eta);
-                     deltaEta = fGrid1->GetDeta(); 
-                     deltaPhi = fGrid1->GetDphi(); 
-                     new ((*fUnitArray)[nBin]) AliJetUnitArray(nBin,0,eta,phi,0.,deltaEta,deltaPhi,kTpc,kOutJet,kPtSmaller,kPtSmaller,kBad,0.,-1);
-                   }
-                 else if(nBin>=fNumUnits+nElements+n0+n1 && nBin<fNumUnits+nElements+n0+n1+n2)
-                   {
-                     phi = eta = 0.;
-                     fGrid2->GetEtaPhiFromIndex2(nBin+1-(fNumUnits+nElements+n0+n1),phi,eta);
-                     deltaEta = fGrid2->GetDeta(); 
-                     deltaPhi = fGrid2->GetDphi(); 
-                     new ((*fUnitArray)[nBin]) AliJetUnitArray(nBin,0,eta,phi,0.,deltaEta,deltaPhi,kTpc,kOutJet,kPtSmaller,kPtSmaller,kBad,0.,-1);
-                   }
-                 else if(nBin>=fNumUnits+nElements+n0+n1+n2 && nBin<fNumUnits+nElements+n0+n1+n2+n3)
-                   {
-                     phi = eta = 0.;
-                     fGrid3->GetEtaPhiFromIndex2(nBin+1-(fNumUnits+nElements+n0+n1+n2),phi,eta);
-                     deltaEta = fGrid3->GetDeta(); 
-                     deltaPhi = fGrid3->GetDphi(); 
-                     new ((*fUnitArray)[nBin]) AliJetUnitArray(nBin,0,eta,phi,0.,deltaEta,deltaPhi,kTpc,kOutJet,kPtSmaller,kPtSmaller,kBad,0.,-1);
-                   }
-                 else if(nBin>=fNumUnits+nElements+n0+n1+n2+n3 && nBin<fNumUnits+nElements+nGaps)
-                   {
-                     phi = eta = 0.;
-                     fGrid4->GetEtaPhiFromIndex2(nBin+1-(fNumUnits+nElements+n0+n1+n2+n3),phi,eta);
-                     deltaEta = fGrid4->GetDeta(); 
-                     deltaPhi = fGrid4->GetDphi(); 
-                     new ((*fUnitArray)[nBin]) AliJetUnitArray(nBin,0,eta,phi,0.,deltaEta,deltaPhi,kTpc,kOutJet,kPtSmaller,kPtSmaller,kBad,0.,-1);
-                   }
-               }
-             } // end if(fDZ)
-           } // end else 2
-         } // end else 1
-       } // end loop on nBin
-    } // end grid type == 1
-  fArrayInitialised = 1;
-}
-
diff --git a/JETAN/AliJetAODReader.h b/JETAN/AliJetAODReader.h
deleted file mode 100644 (file)
index 258cdc4..0000000
+++ /dev/null
@@ -1,93 +0,0 @@
-#ifndef ALIJETAODREADER_H
-#define ALIJETAODREADER_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-//---------------------------------------------------------------------
-// Jet AOD Reader
-// AOD reader for jet analysis
-// Author: Davide Perrino (davide.perrino@cern.ch)
-//---------------------------------------------------------------------
-
-#include "AliJetReader.h"
-#include "AliJetUnitArray.h"
-#include "AliJetGrid.h"
-class AliJetUnitArray;
-class AliEMCALGeometry;
-class AliJetHadronCorrection;
-class AliJetAODReaderHeader;
-class AliJetReaderHeader;
-class AliAODMCParticle;
-class AliAODEvent;
-class TRefArray;
-
-class AliJetAODReader : public AliJetReader
-{
- public: 
-  AliJetAODReader();
-  virtual ~AliJetAODReader();
-
-  TRefArray*   GetReferences() const {return fRef;}
-
-  Bool_t FillMomentumArray(); 
-  static Bool_t AcceptAODMCParticle(AliAODMCParticle *mcP,Short_t flag);
-
-  void   OpenInputFiles();
-  void   ConnectTree(TTree* tree, TObject* data);
-  void   InitUnitArray();
-  void   CreateTasks(TChain* tree);
-  Bool_t ExecTasks(Bool_t procid, TRefArray* refArray);
-
-  void SetInputEvent(const TObject* /*esd*/, const TObject* aod, const TObject* /*mc*/) {fAOD = (AliAODEvent*) aod;}
-  void SetTPCGrid(AliJetGrid *grid)   {fTpcGrid = grid;}
-  void SetEMCalGrid(AliJetGrid *grid) {fEmcalGrid = grid;}
-  // Correction of hadronic energy
-  void SetHadronCorrection(const Int_t flag = 1) {fHCorrection = flag;}
-  void SetHadronCorrector(AliJetHadronCorrection* corr) {fHadCorr = corr;}
-  void SetApplyElectronCorrection(const Int_t flag = 1) {fECorrection = flag; fEFlag=kTRUE;}
-  void SetApplyMIPCorrection(const Bool_t val);
-  void SetApplyFractionHadronicCorrection(Bool_t val);
-  void SetFractionHadronicCorrection(Double_t val);
-
-
- private:
-  Bool_t SetEMCALGeometry();
-  Bool_t FillMomentumArrayMC();
-
-
-  void InitParameters();
-  AliJetAODReader(const AliJetAODReader &det);
-  AliJetAODReader &operator=(const AliJetAODReader &det);
-
- private:
-  AliAODEvent                *fAOD;    //! pointer to aod
-  TRefArray                  *fRef;    //! pointer to array of references to tracks
-  Int_t                       fDebug;  // Debug option
-  Int_t                       fOpt;    // Detector to be used for jet reconstruction
-  AliJetHadronCorrection     *fHadCorr;          //! Pointer to Hadron Correction Object
-  AliJetGrid                 *fTpcGrid;          //! Pointer to grid object
-  AliJetGrid                 *fEmcalGrid;        //! Pointer to grid object
-  AliJetGrid                 *fGrid0;            // Pointer to grid object
-  AliJetGrid                 *fGrid1;            // Pointer to grid object
-  AliJetGrid                 *fGrid2;            // Pointer to grid object
-  AliJetGrid                 *fGrid3;            // Pointer to grid object
-  AliJetGrid                 *fGrid4;            // Pointer to grid object
-  Int_t                       fApplyElectronCorrection;      // Electron correction flag
-  Bool_t                      fApplyMIPCorrection; // Apply MIP or not ? Exclusive with fApplyFractionHadronicCorrection
-  Bool_t                      fApplyFractionHadronicCorrection; // Another type of charged particle energy deposition in EMC
-  Double_t                    fFractionHadronicCorrection; // Fraction of momentum of the TPC track to be subtracted from EMC tower
-  Int_t                       fNumUnits;         // Number of units in the unit object array
-                                                 // (same as num towers in EMCAL)
-  Float_t                     fMass;             // Particle mass
-  Int_t                       fSign;             // Particle sign
-  Int_t                       fNIn;              // Number of Array filled in UnitArray
-  Bool_t                      fDZ;               // Use or not dead zones
-  Int_t                       fNeta;             // Number of bins in eta of tpc grid
-  Int_t                       fNphi;             // Number of bins in phi of tpc grid
-  TRefArray                  *fRefArray;         // array of digit position and energy
-  Bool_t                      fProcId;           // Bool_t for TProcessID synchronization
-  ClassDef(AliJetAODReader,2)
-};
-#endif
diff --git a/JETAN/AliJetAODReaderHeader.cxx b/JETAN/AliJetAODReaderHeader.cxx
deleted file mode 100644 (file)
index 293c768..0000000
+++ /dev/null
@@ -1,42 +0,0 @@
-/**************************************************************************
- * 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.                  *
- **************************************************************************/
-
-//---------------------------------------------------------------------
-// Jet AOD Reader Header
-// Header for the AOD reader in the jet analysis
-// Author: Davide Perrino (davide.perrino@cern.ch)
-//---------------------------------------------------------------------
-#include "AliJetAODReaderHeader.h"
-
-ClassImp(AliJetAODReaderHeader)
-
-//____________________________________________________________________________
-AliJetAODReaderHeader::AliJetAODReaderHeader():
-  AliJetReaderHeader("AliJetAODReaderHeader"), 
-  fNaod(0),
-  fTestFilterMask(0),
-  fReadMC(0),
-  fNonStdBranch("aodExtraTracks"),
-  fReadBranches(kReadStdBranch)
-{
-  // Default constructor  
-}
-
-//____________________________________________________________________________
-AliJetAODReaderHeader::~AliJetAODReaderHeader()
-{
-  // destructor
-}
diff --git a/JETAN/AliJetAODReaderHeader.h b/JETAN/AliJetAODReaderHeader.h
deleted file mode 100644 (file)
index 60cc637..0000000
+++ /dev/null
@@ -1,50 +0,0 @@
-#ifndef ALIJETAODREADERHEADER_H
-#define ALIJETAODREADERHEADER_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-// Jet AOD Reader Header
-// Header for the AOD reader in the jet analysis
-// Author: Davide Perrino (davide.perrino@cern.ch)
-
-#include "AliJetReaderHeader.h"
-class AliJetAODReaderHeader : public AliJetReaderHeader
-{
-
- public:
-  AliJetAODReaderHeader();
-  virtual ~AliJetAODReaderHeader();
-  
-  enum { kReadStdBranch = 1,
-        kReadNonStdBranch = 2 };
-
-  // Getters
-  Int_t   GetNaod()       const {return fNaod;}
-  UInt_t  GetTestFilterMask()   const {return fTestFilterMask;}            
-  TString GetNonStdBranch()     const { return fNonStdBranch; }
-  Bool_t  GetReadStdBranch()    const { return (fReadBranches & kReadStdBranch); }
-  Bool_t  GetReadNonStdBranch() const { return (fReadBranches & kReadNonStdBranch); }
-
-  // Setters
-  virtual void SetNumberOfAOD(Int_t i=1) {fNaod = i;}    
-  virtual void SetTestFilterMask(UInt_t i){fTestFilterMask = i;}
-  virtual void SetReadAODMC(Short_t i){fReadMC = i;}
-  virtual Short_t GetReadAODMC(){return fReadMC;}
-  void SetNonStdBranch(TString name) { fNonStdBranch = name; }
-  void SetReadBranches(UShort_t read) { fReadBranches = read; }
-
-  enum { kDefault = 0, kAllMC = 1 , kChargedMC = 2};
-
- protected:
-  Int_t   fNaod;           // number of aods
-  UInt_t  fTestFilterMask; // Filter Mask for jets, not tested if 0
-  Short_t fReadMC;      // Flag for reading the AODMC infomration, NB. this is not available on the flight...
-  TString fNonStdBranch;       // non-standard branch to read additional tracks
-  UShort_t fReadBranches;      // which branches to read from
-
-  ClassDef(AliJetAODReaderHeader,5);
-};
-#endif
index ad3c944..27188f3 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
+/* $Id$ */
+
+//--------------------------------------------------
+// Method implementation for background studies and background subtraction with UA1 algorithms
+//
+// Author: magali.estienne@subatech.in2p3.fr
+//-------------------------------------------------
+
 #include <Riostream.h> 
-#include <TChain.h>
-#include <TFile.h>
 #include <TList.h>
-#include <TArrayF.h>
 #include <TClonesArray.h>
-#include <TF1.h>
-#include <TString.h>
-
-#include "AliJetHeader.h"
-#include "AliJetReader.h"
-#include "AliJetReaderHeader.h"
-#include "AliFastJetFinder.h"
-#include "AliFastJetHeaderV1.h"
-#include "AliJetReaderHeader.h"
-#include "AliJetReader.h"
-#include "AliJetUnitArray.h"
-#include "AliFastJetInput.h"
-#include "AliESDEvent.h"
-
-
-#include "fastjet/PseudoJet.hh"
-#include "fastjet/ClusterSequenceArea.hh"
-#include "fastjet/AreaDefinition.hh"
-#include "fastjet/JetDefinition.hh"
-// get info on how fastjet was configured
-#include "fastjet/config.h"
-
-#ifdef ENABLE_PLUGIN_SISCONE
-#include "fastjet/SISConePlugin.hh"
-#endif
-
-#include<sstream>  // needed for internal io
-#include<vector> 
-#include <cmath> 
+#include <TH1F.h>
+#include <TH2F.h>
 
-using namespace std;
+#include "AliAODJetEventBackground.h"
+#include "AliUA1JetHeaderV1.h"
+#include "AliJetCalTrk.h"
 #include "AliJetBkg.h"
 
+
+using namespace std;
+
 ClassImp(AliJetBkg)
 
 ////////////////////////////////////////////////////////////////////////
 
 AliJetBkg::AliJetBkg():
   TObject(),
-  fReader(0),
-  fHeader(0),
-  fInputFJ(0)
+  fEvent(0x0),
+  fHeader(0x0),
+  fDebug(0),
+  fhEtBackg(0x0),
+  fhAreaBackg(0x0)
 {
   // Default constructor
-
+  for(int i = 0;i < kMaxJets;i++){
+    fhAreaJet[i] = fhEtJet[i] = 0;
+  }
 }
-//______________________________________________________________________
+
+//----------------------------------------------------------------
 AliJetBkg::AliJetBkg(const AliJetBkg& input):
   TObject(input),
-    fReader(input.fReader),
-    fHeader(input.fHeader),
-    fInputFJ(input.fInputFJ)
+  fEvent(input.fEvent),
+  fHeader(input.fHeader),
+  fDebug(input.fDebug),
+  fhEtBackg(input.fhEtBackg),
+  fhAreaBackg(input.fhAreaBackg)
 {
   // copy constructor
-
-}
-//______________________________________________________________________
-AliJetBkg& AliJetBkg::operator=(const AliJetBkg& source){
-    // Assignment operator. 
-    this->~AliJetBkg();
-    new(this) AliJetBkg(source);
-    return *this;
+  for(int i = 0;i < kMaxJets;i++){
+    fhAreaJet[i] = input.fhAreaJet[i];
+    fhEtJet[i] = input.fhEtJet[i];
+  }
 
 }
 
+//----------------------------------------------------------------
+AliJetBkg::~AliJetBkg()
+{
+  // Destructor
+  if(fhEtBackg) delete  fhEtBackg;
+  if(fhAreaBackg) delete  fhAreaBackg;
+   for(int i = 0;i < kMaxJets;i++){
+     if(fhAreaJet[i]) delete fhAreaJet[i];
+     if(fhEtJet[i])  delete fhEtJet[i];
+   }
 
-//___________________________________________________________________
-  void AliJetBkg::BkgFastJetb(Double_t& rho,Double_t& sigma, 
-Double_t& meanarea){
+}
 
-    AliFastJetHeaderV1 *header = (AliFastJetHeaderV1*)fHeader; 
-    Bool_t debug  = header->GetDebug();     // debug option 
-    if(debug)cout<<"===============  AliJetBkg::BkgFastJetb()  =========== "<<endl;
-  vector<fastjet::PseudoJet> inputParticles=fInputFJ->GetInputParticles();
-  
-  //cout<<"printing inputParticles for BKG "<<inputParticles.size()<<endl;
-  
+//----------------------------------------------------------------
+Bool_t AliJetBkg::PtCutPass(Int_t id, Int_t nTracks)
+{
+  // Check if track or cell passes the cut flag
+  if(id < nTracks && fEvent->GetCalTrkTrack(id)->GetCutFlag() == 1) 
+   return kTRUE;
+  else return kFALSE;
 
-   
+}
 
-  double rParamBkg = header->GetRparamBkg(); //Radius for background calculation
+//----------------------------------------------------------------
+Bool_t AliJetBkg::SignalCutPass(Int_t id, Int_t nTracks)
+{
+  // Check if track or cell passes the cut flag
+  if(id < nTracks && fEvent->GetCalTrkTrack(id)->GetSignalFlag() == 1)
+    return kTRUE;
+  else return kFALSE;
 
-  Double_t medianb,sigmab,meanareab;
-  CalcRhob(medianb,sigmab,meanareab,inputParticles,rParamBkg,"All");
-  rho=medianb;
-  sigma=sigmab;
-  meanarea=meanareab;
 }
-//_________________________________________________________________
-
-  void AliJetBkg::BkgFastJetWoHardest(Double_t& rho,Double_t& sigma, 
-Double_t& meanarea){
-    AliFastJetHeaderV1 *header = (AliFastJetHeaderV1*)fHeader; 
-    Bool_t debug  = header->GetDebug();     // debug option 
-    if(debug)cout<<"===============  AliJetBkg::BkgWoHardest()  =========== "<<endl;
-  vector<fastjet::PseudoJet> inputParticles=fInputFJ->GetInputParticles();
-  
-  //cout<<"printing inputParticles for BKG "<<inputParticles.size()<<endl;   
-  double rParamBkg = header->GetRparamBkg(); //Radius for background calculation  
-  Double_t medianb,sigmab,meanareab;
-  CalcRhoWoHardest(medianb,sigmab,meanareab,inputParticles,rParamBkg,"All");
-  rho=medianb;
-  sigma=sigmab;
-  meanarea=meanareab;
 
+//----------------------------------------------------------------
+Float_t AliJetBkg::CalcJetAreaEtaCut(Float_t radius, const Float_t etaJet)
+{
+  // Calculate jet area taking into account an acceptance cut in eta
+  AliUA1JetHeader* header = (AliUA1JetHeader*) fHeader;
+  Float_t detamax = etaJet + radius;
+  Float_t detamin = etaJet - radius;
+  Float_t accmax = 0.0; Float_t accmin = 0.0;
+  if(detamax > header->GetLegoEtaMax()){ // sector outside etamax
+    Float_t h = header->GetLegoEtaMax() - etaJet;
+    accmax = radius*radius*TMath::ACos(h/radius) - h*TMath::Sqrt(radius*radius - h*h);
   }
-
-//____________________________________________________________________
-
- void AliJetBkg::CalcRhob(Double_t& median,Double_t& 
-                         sigma,Double_t& 
-                         meanarea,vector<fastjet::PseudoJet> inputParticles,Double_t 
-                         rParamBkg,TString method){
-  //calculate rho using the fastjet method
-
-  AliFastJetHeaderV1 *header = (AliFastJetHeaderV1*)fHeader;
-  Bool_t debug  = header->GetDebug();     // debug option
-
-  fastjet::Strategy strategy = header->GetStrategy();
-  fastjet::RecombinationScheme recombScheme = header->GetRecombScheme();
-  fastjet::JetAlgorithm algorithm = header->GetAlgorithm(); 
-  fastjet::JetDefinition jetDef(algorithm, rParamBkg, recombScheme, strategy);
-
-  // create an object that specifies how we to define the area
-  fastjet::AreaDefinition areaDef;
-  double ghostEtamax = header->GetGhostEtaMax(); 
-  double ghostArea   = header->GetGhostArea(); 
-  int    activeAreaRepeats = header->GetActiveAreaRepeats(); 
-
-  // now create the object that holds info about ghosts
-
-  
-
-  fastjet::GhostedAreaSpec ghost_spec(ghostEtamax, activeAreaRepeats, ghostArea);
-  // and from that get an area definition
-  fastjet::AreaType areaType = header->GetAreaType();
-  areaDef = fastjet::AreaDefinition(areaType,ghost_spec);
-  
-  //fastjet::ClusterSequenceArea clust_seq(inputParticles, jetDef);
-  fastjet::ClusterSequenceArea clust_seq(inputParticles, jetDef,areaDef);
-  TString comment = "Running FastJet algorithm for BKG calculation with the following setup. ";
-  comment+= "Jet definition: ";
-  comment+= TString(jetDef.description());
-  //  comment+= ". Area definition: ";
-  //comment+= TString(areaDef.description());
-  comment+= ". Strategy adopted by FastJet: ";
-  comment+= TString(clust_seq.strategy_string());
-  comment+= Form("Method: %s",method.Data());
-  header->SetComment(comment);
-  if(debug){
-    cout << "--------------------------------------------------------" << endl;
-    cout << comment << endl;
-    cout << "--------------------------------------------------------" << endl;
+  if(detamin < header->GetLegoEtaMin()){ // sector outside etamin
+    Float_t h = header->GetLegoEtaMax() + etaJet;
+    accmin = radius*radius*TMath::ACos(h/radius) - h*TMath::Sqrt(radius*radius - h*h);
   }
-
-  vector<fastjet::PseudoJet> inclusiveJets = clust_seq.inclusive_jets(0.);
-  vector<fastjet::PseudoJet> jets = sorted_by_pt(inclusiveJets); 
-
-  //cout<<"# of BKG jets = "<<jets.size()<<endl;
-      //  for (size_t j = 0; j < jets.size(); j++) { // loop for jets   
-      //printf("BKG Jet found %5d %9.5f %8.5f %10.3f %4.4f 
-      //\n",(Int_t)j,jets[j].rap(),jets[j].phi(),jets[j].perp(),
-      //clust_seq.area(jets[j]));
-      // }
-  
   
-  double phiMin = 0, phiMax = 0, rapMin = 0, rapMax = 0;
+  return radius*radius*TMath::Pi() - accmax - accmin;
 
-    phiMin = 0;
-    phiMax = 2*TMath::Pi();
-  rapMax = ghostEtamax - rParamBkg;
-  rapMin = - ghostEtamax + rParamBkg;
-
-
-  fastjet::RangeDefinition range(rapMin, rapMax, phiMin, phiMax);
-
-
-  double medianb, sigmab, meanareab;
-  clust_seq.get_median_rho_and_sigma(inclusiveJets, range, false, medianb, sigmab, meanareab, false);
-  median=medianb;
-  sigma=sigmab;
-  meanarea=meanareab; 
-
- }
-
-//____________________________________________________________________
-
-
- void AliJetBkg::CalcRhoWoHardest(Double_t& median,Double_t& 
-sigma,Double_t& 
-meanarea,vector<fastjet::PseudoJet> inputParticles,Double_t 
-rParamBkg,TString method){
-  //calculate rho using the fastjet method
-
-  AliFastJetHeaderV1 *header = (AliFastJetHeaderV1*)fHeader;
-  Bool_t debug  = header->GetDebug();     // debug option
-
-  fastjet::Strategy strategy = header->GetStrategy();
-  fastjet::RecombinationScheme recombScheme = header->GetRecombScheme();
-  fastjet::JetAlgorithm algorithm = header->GetAlgorithm(); 
-  fastjet::JetDefinition jetDef(algorithm, rParamBkg, recombScheme, strategy);
-
-  // create an object that specifies how we to define the area
-  fastjet::AreaDefinition areaDef;
-  double ghostEtamax = header->GetGhostEtaMax(); 
-  double ghostArea   = header->GetGhostArea(); 
-  int    activeAreaRepeats = header->GetActiveAreaRepeats(); 
-
-  // now create the object that holds info about ghosts
+}
 
+//----------------------------------------------------------------
+void AliJetBkg::CalcJetAndBckgAreaEtaCut(Bool_t calcOutsideArea, Float_t radius, const Int_t nJets, const Float_t* etaJet, Float_t* &areaJet, Float_t &areaOut)
+{
+  // Calculate jet and bacground areas taking into account an acceptance cut in eta
 
-  fastjet::GhostedAreaSpec ghost_spec(ghostEtamax, activeAreaRepeats, ghostArea);
-  // and from that get an area definition
-  fastjet::AreaType areaType = header->GetAreaType();
-  areaDef = fastjet::AreaDefinition(areaType,ghost_spec);
-  //cout<<"rParamBkg="<<rParamBkg<<"  ghostEtamax="<<ghostEtamax<<"  ghostArea="<<ghostArea<<" areadef="<<TString(areaDef.description())<<endl;
-  //fastjet::ClusterSequenceArea clust_seq(inputParticles, jetDef);
-  fastjet::ClusterSequenceArea clust_seq(inputParticles,jetDef,areaDef);
-  TString comment = "Running FastJet algorithm for BKG calculation with the following setup. ";
-  comment+= "Jet definition: ";
-  comment+= TString(jetDef.description());
-  //  comment+= ". Area definition: ";
-  //comment+= TString(areaDef.description());
-  comment+= ". Strategy adopted by FastJet: ";
-  comment+= TString(clust_seq.strategy_string());
-  comment+= Form("Method: %s",method.Data());
-  header->SetComment(comment);
-  if(debug){
-    cout << "--------------------------------------------------------" << endl;
-    cout << comment << endl;
-    cout << "--------------------------------------------------------" << endl;
+  AliUA1JetHeader* header = (AliUA1JetHeader*) fHeader;
+  areaOut = (header->GetLegoEtaMax()-header->GetLegoEtaMin())*(header->GetLegoPhiMax() - header->GetLegoPhiMin());
+  for(Int_t k=0; k<nJets; k++){
+    areaJet[k] = CalcJetAreaEtaCut(radius, etaJet[k]);
+    if(calcOutsideArea) areaOut = areaOut - areaJet[k];
   }
 
-  vector<fastjet::PseudoJet> inclusiveJets = clust_seq.inclusive_jets(0.);
-  vector<fastjet::PseudoJet> jets = sorted_by_pt(inclusiveJets); 
-  vector<fastjet::PseudoJet> jets2=sorted_by_pt(inclusiveJets);
-  if(jets2.size()>=2) jets2.erase(jets2.begin(),jets2.begin()+1);
-  
-   
-  
-  double phiMin = 0, phiMax = 0, rapMin = 0, rapMax = 0;
-
-    phiMin = 0;
-    phiMax = 2*TMath::Pi();
-  rapMax = ghostEtamax - rParamBkg;
-  rapMin = - ghostEtamax + rParamBkg;
-
-
-  fastjet::RangeDefinition range(rapMin, rapMax, phiMin, phiMax);
-
-
-  double medianb, sigmab, meanareab;
-  clust_seq.get_median_rho_and_sigma(jets2, range, false, medianb, sigmab, 
-meanareab, false);
-  median=medianb;
-  sigma=sigmab;
-  meanarea=meanareab; 
-
-  
- }
-
-
-//___________________________________________________________________
-Float_t AliJetBkg::BkgFastJet(){
-// Return background  
-  AliFastJetHeaderV1 *header = (AliFastJetHeaderV1*)fHeader;
-  Bool_t debug  = header->GetDebug();     // debug option
-
-  if(debug)cout<<"===============  AliJetBkg::BkgFastJet()  =========== "<<endl;
-  vector<fastjet::PseudoJet> inputParticles=fInputFJ->GetInputParticles();
-  
-  if(debug)cout<<"printing inputParticles for BKG "<<inputParticles.size()<<endl;
-  
-  for(UInt_t i=0;i<inputParticles.size();i++){
-    //  cout<<"                "<<inputParticles[i].px()<<" "<<inputParticles[i].py()<<" "<<inputParticles[i].pz()<<endl;
-    
-  }
-   
-  double rParamBkg = header->GetRparamBkg(); //Radius for background calculation
-  Double_t rho=CalcRho(inputParticles,rParamBkg,"All");
-  if(debug)cout<<"-------- rho (from all part)="<<rho<<endl; 
-  return rho;
 }
-//___________________________________________________________________
-Float_t  AliJetBkg::BkgChargedFastJet(){
-// Background for charged jets
-  AliFastJetHeaderV1 *header = (AliFastJetHeaderV1*)fHeader;
-  Bool_t debug  = header->GetDebug();     // debug option
-
-  if(debug)cout<<"===============  AliJetBkg::BkgChargedFastJet()  =========== "<<endl;
 
-  vector<fastjet::PseudoJet> inputParticlesCharged=fInputFJ->GetInputParticlesCh();
+//----------------------------------------------------------------
+void AliJetBkg::SubtractBackg(const Int_t& nIn, const Int_t&nJ, Float_t&etbgTotalN, Float_t&sigmaN,
+                              const Float_t* ptT, const Float_t* etaT, const Float_t* phiT,
+                              Float_t* etJet, const Float_t* etaJet, const Float_t* phiJet,
+                              Float_t* etsigJet, Int_t* multJetT, Int_t* multJetC, Int_t* multJet,
+                              Int_t* injet, Float_t* &areaJet)
+{
+  //
+  // Background subtraction using cone method but without correction in dE/deta distribution
+  // Cases to take into account the EMCal geometry are included
+  //
   
-  if(debug)cout<<"printing CHARGED inputParticles for BKG "<<inputParticlesCharged.size()<<endl;
-
-  for(UInt_t i=0;i<inputParticlesCharged.size();i++){
-    // cout<<"                "<<inputParticlesCharged[i].px()<<" "<<inputParticlesCharged[i].py()<<" "<<inputParticlesCharged[i].pz()<<endl;
-
-  } 
-
-  double rParam = header->GetRparam();
+  AliUA1JetHeader* header = (AliUA1JetHeader*) fHeader;
+  //calculate energy inside and outside cones
+  fDebug = header->GetDebug();
+  Float_t rc = header->GetRadius();
+  Float_t etOut = 0;
+  // Get number of tracks from EventCalTrk
+  Int_t nTracks = fEvent->GetNCalTrkTracks();
+
+  Float_t etIn[kMaxJets] = {0};
+  Float_t areaOut = 0.;
+
+  for(Int_t jpart = 0; jpart < nIn; jpart++){ // loop for all particles in array
+
+    for(Int_t ijet=0; ijet<nJ; ijet++){
+      Float_t deta = etaT[jpart] - etaJet[ijet];
+      Float_t dphi = phiT[jpart] - phiJet[ijet];
+      if (dphi < -TMath::Pi()) dphi= -dphi - 2.0 * TMath::Pi();
+      if (dphi > TMath::Pi()) dphi = 2.0 * TMath::Pi() - dphi;
+      Float_t dr = TMath::Sqrt(deta * deta + dphi * dphi);
+      if(dr <= rc){ // particles inside this cone
+        if(jpart < nTracks) multJetT[ijet]++;
+        else multJetC[ijet]++;
+        multJet[ijet]++;
+        injet[jpart] = ijet;
+        if(PtCutPass(jpart,nTracks)){ // pt cut
+          etIn[ijet] += ptT[jpart];
+          if(SignalCutPass(jpart,nTracks))
+            etsigJet[ijet]+= ptT[jpart];
+        }
+        break;
+      }
+    }// end jets loop
+
+    if((injet[jpart] == -1) &&
+       (PtCutPass(jpart,nTracks))){
+      etOut += ptT[jpart]; // particle outside cones and pt cut
+    }
+  } //end particle loop
+
+  // Calculate jet and background areas
+  Bool_t calcAreaOut = kTRUE;
+  CalcJetAndBckgAreaEtaCut(calcAreaOut,rc, nJ, etaJet, areaJet, areaOut);
+
+  //subtract background using area method
+  for(Int_t ljet=0; ljet<nJ; ljet++){
+    Float_t areaRatio = areaJet[ljet]/areaOut;
+    etJet[ljet] = etIn[ljet]-etOut*areaRatio; // subtraction
+  }
 
-  Double_t rho=CalcRho(inputParticlesCharged,rParam,"Charg");
+  // estimate new total background
+  Float_t areaT = 0;
+  areaT = (header->GetLegoEtaMax()-header->GetLegoEtaMin())*(header->GetLegoPhiMax()-header->GetLegoPhiMin());
+  etbgTotalN = etOut*areaT/areaOut;
+
+  // estimate standard deviation of background
+  Int_t count = 0;
+  for(Int_t jpart = 0; jpart < nIn; jpart++){ // loop for all particles in array
+    if((injet[jpart] == -1) &&
+       (PtCutPass(jpart,nTracks))){
+      sigmaN += etbgTotalN/areaT - ptT[jpart];
+      // To be checked (Division by jet area to obtain standard deviation of rho ?)
+
+      count=count+1;
+    }
+  }
+  if (count>0)
+    sigmaN=TMath::Sqrt(TMath::Abs(sigmaN)/count);
 
-  if(debug)cout<<"-------- rho (from CHARGED part)="<<rho<<endl; 
-  return rho;
 }
 
-
-
-Float_t AliJetBkg::BkgStat()
+//----------------------------------------------------------------
+void AliJetBkg::SubtractBackgStat(const Int_t& nIn, const Int_t&nJ,Float_t&etbgTotalN, Float_t&sigmaN,
+                                  const Float_t* ptT, const Float_t* etaT, const Float_t* phiT,
+                                  Float_t* etJet, const Float_t* etaJet, const Float_t* phiJet,
+                                  Float_t* etsigJet, Int_t* multJetT, Int_t* multJetC, Int_t* multJet,
+                                  Int_t* injet, Float_t* &areaJet)
 {
+  //
   //background subtraction using statistical method
-  AliFastJetHeaderV1 *header = (AliFastJetHeaderV1*)fHeader;
-  Bool_t debug  = header->GetDebug();     // debug option
-
-  if(debug)cout<<"==============AliJetBkg::BkgStat()============="<<endl;
-  //TO BE IMPLEMENTED 
-  // Int_t nTracks= fReader->GetESD()->GetNumberOfTracks();
-  Int_t nTracks= 0;
-  TF1 fun("fun",BkgFunction,0,800,1);
-  Double_t enTot=fun.Eval(nTracks);
-  Double_t accEMCal=2*0.7*110./180*TMath::Pi();//2.68 area of EMCal
-  return enTot/accEMCal;
-
-}
-
-////////////////////////////////////////////////////////////////////////
-Float_t AliJetBkg::BkgFastJetCone(TClonesArray* fAODJets)
-{
+  // Cases to take into account the EMCal geometry are included
+  //
 
-  // Cone background subtraction method applied on the fastjet: REmove the particles of the
-  // two largest jets with the given R from the estimation of new rho. 
-
-  AliFastJetHeaderV1 *header = (AliFastJetHeaderV1*)fHeader;
-  Bool_t debug  = header->GetDebug();     // debug option
-
-  if(debug)cout<<"==============AliJetBkg::SubtractFastJetBackgCone()============="<<endl;
-
-  Float_t rc= header->GetRparam();
-
-  //Hard wired Calorimeter area (get it later from the AliJetReaderHeader.h)
-  Double_t accEMCal=2*0.7*110./180*TMath::Pi();//2.68 area of EMCal
-
-  Int_t nJ=fAODJets->GetEntries(); //this must be the # of jets... 
-  if(debug)cout<<"nJets:  "<<nJ<<endl;
+  AliUA1JetHeader* header = (AliUA1JetHeader*) fHeader;
+  Float_t etbgStat = header->GetBackgStat(); // pre-calculated background
   
-
-  //begin unit array 
-  TClonesArray* fUnit = fReader->GetUnitArray();
-  if(fUnit == 0) { cout << "Could not get the momentum array" << endl; return -99; }
-
-  Int_t nIn = fUnit->GetEntries();
-  if(nIn == 0) { cout << "entries = 0 ; Event empty !!!" << endl ; return -99; }
+  //calculate energy inside
+  Float_t rc= header->GetRadius();
+  Float_t etIn[kMaxJets] = {0.0};
+  // Get number of tracks from EventCalTrk
+  Int_t nTracks = fEvent->GetNCalTrkTracks();
+  Float_t areaOut = 0.;
+
+  for(Int_t jpart = 0; jpart < nIn; jpart++)
+    { // loop for all particles in array
+      
+      for(Int_t ijet=0; ijet<nJ; ijet++)
+       {
+         Float_t deta = etaT[jpart] - etaJet[ijet];
+         Float_t dphi = phiT[jpart] - phiJet[ijet];
+         if (dphi < -TMath::Pi()) dphi= -dphi - 2.0 * TMath::Pi();
+         if (dphi > TMath::Pi()) dphi = 2.0 * TMath::Pi() - dphi;
+         Float_t dr = TMath::Sqrt(deta * deta + dphi * dphi);
+          if(dr <= rc){ // particles inside this cone
+            if(jpart < nTracks) multJetT[ijet]++;
+            else multJetC[ijet]++;
+            multJet[ijet]++;
+            injet[jpart] = ijet;
+
+            if(PtCutPass(jpart,nTracks)){ // pt cut
+              etIn[ijet] += ptT[jpart];
+             if(SignalCutPass(jpart,nTracks))
+               etsigJet[ijet]+= ptT[jpart];
+            }
+            break;
+          }
+       }// end jets loop
+    } //end particle loop
   
-  // Information extracted from fUnitArray
-  // load input vectors and calculate total energy in array
-  Float_t pt,eta,phi;
-  Float_t jeteta = 0,jetphi = 0,jeteta1 = 0, jetphi1 = 0;
-  Float_t rhoback=0.0;
-
-  Float_t ptallback=0.0; //particles without the jet
-  Float_t restarea=accEMCal; //initial area set 
-  Bool_t acc=0;
-  Bool_t acc1=0;
-  Float_t rCone=0.4;
-  
-  if(nJ==1) { 
-    AliAODJet *jettmp = (AliAODJet*)(fAODJets->At(0));
-    jeteta=jettmp->Eta();
-    jetphi=jettmp->Phi();
-    acc=EmcalAcceptance(jeteta,jetphi,rCone);
-    if(acc==1)restarea= accEMCal-TMath::Pi()*rc*rc;
-    if(debug)cout<<" acc  "<<acc<<endl;
+  // Calculate jet and background areas
+  Bool_t calcAreaOut = kFALSE;
+  CalcJetAndBckgAreaEtaCut(calcAreaOut,rc, nJ, etaJet, areaJet, areaOut);
+
+  //subtract background using area method
+  for(Int_t ljet=0; ljet<nJ; ljet++){
+    Float_t areaRatio = areaJet[ljet]/areaOut;
+    etJet[ljet] = etIn[ljet]-etbgStat*areaRatio; // subtraction
   }
-
-  
-  if(nJ>=2) { 
-    AliAODJet *jettmp = (AliAODJet*)(fAODJets->At(0));
-    AliAODJet *jettmp1 = (AliAODJet*)(fAODJets->At(1));
-    jeteta=jettmp->Eta();
-    jetphi=jettmp->Phi();
-    jeteta1=jettmp1->Eta();
-    jetphi1=jettmp1->Phi(); 
-    acc=EmcalAcceptance(jeteta,jetphi,rCone);
-    acc1=EmcalAcceptance(jeteta1,jetphi1,rCone);
-    if(acc1==1 && acc==1)restarea= accEMCal-2*TMath::Pi()*rc*rc;
-    if(acc1==1 && acc==0)restarea= accEMCal-TMath::Pi()*rc*rc;
-    if(acc1==0 && acc==1)restarea= accEMCal-TMath::Pi()*rc*rc;
-
-    if(debug)cout<<" acc1="<<acc<<"  acc2="<<acc1<<"  restarea="<<restarea<<endl;
-
+  Int_t count=0;
+  etbgTotalN = etbgStat;
+
+  // estimate standard deviation of background
+  Float_t areaT = 0;
+  areaT = (header->GetLegoEtaMax()-header->GetLegoEtaMin())*(header->GetLegoPhiMax()-header->GetLegoPhiMin());
+  for(Int_t jpart = 0; jpart < nIn; jpart++){ // loop for all particles in array
+    if((injet[jpart] == -1) &&
+       (PtCutPass(jpart,nTracks))){
+      sigmaN += etbgTotalN/areaT - ptT[jpart];
+      count=count+1;
+    }
   }
-  
-  // cout<<" nIn = "<<nIn<<endl;
-  Float_t sumpt=0;
-  for(Int_t i=0; i<nIn; i++) 
-    { //Unit Array Loop
-      AliJetUnitArray *uArray = (AliJetUnitArray*)fUnit->At(i);
-      if(uArray->GetUnitEnergy()>0.){
-       
-       pt    = uArray->GetUnitEnergy();
-               eta   = uArray->GetUnitEta();
-       phi   = uArray->GetUnitPhi();
-
-       //cout<<"test emcal acceptance for particles "<<EmcalAcceptance(eta,phi,0.)<<endl;
-       
-       Float_t deta=0.0, dphi=0.0, dr=100.0;
-       Float_t deta1=0.0, dphi1=0.0, dr1=100.0;
-       
-       //cout<<i<<"  pt="<<pt<<"  eta="<<eta<<"  phi="<<phi<<endl;
-       if(phi>1.396 && phi<3.316 && eta>-0.7 && eta<0.7){
-         sumpt+=pt;
-         //if(i<30)cout<<i<<" pt unit = "<<pt<<endl;
-
-         if(nJ==1 && acc==1) { 
-           deta = eta - jeteta;
-           dphi = phi - jetphi;
-           if (dphi < -TMath::Pi()) dphi= -dphi - 2.0 * TMath::Pi();
-           if (dphi > TMath::Pi()) dphi = 2.0 * TMath::Pi() - dphi;
-           dr = TMath::Sqrt(deta * deta + dphi * dphi);
-           if(dr<=rc)sumpt-=pt;
-      &