Merge branch 'master' of https://git.cern.ch/reps/AliRoot
authorcholm <Christian.Holm.Christensen@cern.ch>
Tue, 28 Oct 2014 21:14:49 +0000 (22:14 +0100)
committercholm <Christian.Holm.Christensen@cern.ch>
Tue, 28 Oct 2014 21:14:49 +0000 (22:14 +0100)
768 files changed:
.DS_Store [new file with mode: 0644]
ACORDE/CMakeLists.txt
AD/AliADQADataMakerRec.cxx
AD/AliADRawStream.cxx
AD/AliADReconstructor.cxx
AD/AliADReconstructor.h
AD/AliADdigit.cxx
AD/AliADdigit.h
AD/CMakeLists.txt
ALIROOT/CMakeLists.txt
ANALYSIS/AliAnalysisTaskPIDqa.cxx
ANALYSIS/AliAnalysisTaskSE.cxx
ANALYSIS/AliAnalysisTaskSE.h
ANALYSIS/AliAnalysisUtils.cxx
ANALYSIS/AliCentralitySelectionTask.cxx
ANALYSIS/AliEPSelectionTask.cxx
ANALYSIS/AliPhysicsSelection.cxx
ANALYSIS/AliTriggerAnalysis.cxx
ANALYSIS/AliTriggerAnalysis.h
ANALYSIS/CMakeLists.txt
ANALYSIS/ESDfilter/AliAnalysisTaskESDfilter.cxx
ANALYSIS/TenderSupplies/AliPHOSTenderSupply.cxx
ANALYSIS/TenderSupplies/AliPHOSTenderSupply.h
ANALYSIS/macros/train/AddMCGenAmpt.C [new file with mode: 0644]
BCM/CMakeLists.txt
CMakeLists.txt
CORRFW/AliCFEventRecCuts.cxx
CORRFW/CMakeLists.txt
DIME/CMakeLists.txt
DIME/DCommon.h
DIME/TDime.cxx
DIME/dimemcv1.05.f
DPMJET/CMakeLists.txt
EMCAL/AliEMCALRecoUtils.cxx
EMCAL/CMakeLists.txt
EMCAL/doc/EMCALDocumentation.tex
EMCAL/doc/bibliography.tex
EMCAL/doc/figures/DCalPHOS.jpg [new file with mode: 0644]
EMCAL/doc/figures/emc-module.jpg [new file with mode: 0644]
EMCAL/doc/figures/emc-sm.jpg [new file with mode: 0644]
EMCAL/doc/geometry.tex
EMCAL/doc/introduction.tex
EMCAL/macros/DumpEMCalTriggerOCDB.C [new file with mode: 0644]
EPOS/CMakeLists.txt
EVE/CMakeLists.txt
EVE/CMakelibEveDet.pkg
EVE/CMakelibEveHLT.pkg
EVE/EveDet/AliEveMUONTrack.cxx
EVE/alice-macros/esd_V0.C
EVE/alice-macros/esd_cascade.C
EVE/macros/alieve_online_new.C
EVGEN/AliDecayerExodus.cxx
EVGEN/AliGenEMCocktail.cxx
EVGEN/AliGenEMCocktail.h
EVGEN/AliGenEMlib.cxx
EVGEN/AliGenEMlib.h
EVGEN/AliGenExtFile.cxx
EVGEN/AliGenPileup.cxx
EVGEN/AliGenPileup.h
EVGEN/AliGenTunedOnPbPb.cxx
EVGEN/CMakeLists.txt
FASTSIM/CMakeLists.txt
FASTSIM/fastGenEMCocktail.C
FIT/CMakeLists.txt
FMD/AliFMDReconstructor.cxx
FMD/CMakeLists.txt
HERWIG/CMakeLists.txt
HIJING/CMakeLists.txt
HLT/CMakeLists.txt
HLT/QA/tasks/AliAnalysisTaskHLT.cxx
HLT/QA/tasks/AliAnalysisTaskHLTCentralBarrel.cxx
HLT/TPCLib/HWCFemulator/AliHLTTPCHWClusterMerger.h
HMPID/CMakeLists.txt
ITS/AliITSMeanVertexer.cxx
ITS/AliITSQADataMakerRec.cxx
ITS/AliITSVertexer3D.cxx
ITS/AliITSVertexerZTest.C
ITS/CMakeLists.txt
ITS/DoVerticesSPD.C
ITS/UPGRADE/AliITSUClusterizer.cxx
ITS/UPGRADE/AliITSURecoDet.cxx
ITS/UPGRADE/AliITSURecoDet.h
ITS/UPGRADE/AliITSURecoLayer.h
ITS/UPGRADE/AliITSURecoParam.cxx
ITS/UPGRADE/AliITSURecoParam.h
ITS/UPGRADE/AliITSURecoSens.h
ITS/UPGRADE/AliITSUReconstructor.cxx
ITS/UPGRADE/AliITSUTrackerCooked.cxx
ITS/UPGRADE/CMakeLists.txt
ITS/UPGRADE/macros/QA/AliITSUComparisonPileup.C
ITS/UPGRADE/testITSU/MakeITSRecoParam.C
ITS/macrosSDD/CheckSDDInESD.C
ITS/oldmacros/AliITSVertexerTracksTest2.C
JETAN/AliAnalysisTaskFastEmbedding.cxx
JETAN/AliAnalysisTaskJetBackgroundSubtract.cxx
JETAN/AliAnalysisTaskJetCluster.cxx
JETAN/CMakeLists.txt
LHAPDF/CMakeLists.txt
LHAPDF/CMakeliblhapdf.pkg
LHAPDF/CMakeliblhapdf5_9_1.pkg [new file with mode: 0644]
MFT/AliAnalysisTaskMFTExample.cxx
MFT/AliMFTAnalysisTools.cxx
MFT/AliMFTAnalysisTools.h
MFT/AliMFTPlane.cxx
MFT/CMakeLists.txt
MICROCERN/CMakeLists.txt
MONITOR/CMakeLists.txt
MONITOR/CMakelibMONITOR.pkg
MONITOR/CMakelibMONITORzmq.pkg
MONITOR/alieventserver/AliEventServer.cxx
MONITOR/alieventserver/AliEventServerReconstruction.cxx
MONITOR/alieventserver/AliEventServerReconstruction.h
MONITOR/alieventserver/alieventserver.rootrc
MONITOR/alistoragemanager/setupStorageDatabase.sh [deleted file]
MUON/AliMUONAlignmentTask.cxx
MUON/AliMUONCheck.cxx
MUON/CMakeLists.txt
MUON/MUONefficiency.C
MUON/MUONmassPlot_ESD.C
OADB/CMakeLists.txt
OADB/CMakelibOADB.pkg
OADB/COMMON/CENTRALITY/data/centrality.root
PHOS/AliPHOSPIDv1.cxx
PHOS/CMakeLists.txt
PMD/CMakeLists.txt
PWG/CMakeLists.txt
PWG/CMakelibPWGDevNanoAOD.pkg
PWG/CMakelibPWGEMCAL.pkg
PWG/CMakelibPWGflowTasks.pkg
PWG/CaloTrackCorrBase/AliAnaCaloTrackCorrBaseClass.cxx
PWG/CaloTrackCorrBase/AliAnaCaloTrackCorrBaseClass.h
PWG/CaloTrackCorrBase/AliAnaCaloTrackCorrMaker.cxx
PWG/CaloTrackCorrBase/AliAnalysisTaskCaloTrackCorrelation.cxx
PWG/CaloTrackCorrBase/AliAnalysisTaskCaloTrackCorrelationM.cxx
PWG/CaloTrackCorrBase/AliAnalysisTaskCounter.cxx
PWG/CaloTrackCorrBase/AliCaloPID.cxx
PWG/CaloTrackCorrBase/AliCaloTrackAODReader.cxx
PWG/CaloTrackCorrBase/AliCaloTrackESDReader.cxx
PWG/CaloTrackCorrBase/AliCaloTrackMCReader.cxx
PWG/CaloTrackCorrBase/AliCaloTrackMCReader.h
PWG/CaloTrackCorrBase/AliCaloTrackReader.cxx
PWG/CaloTrackCorrBase/AliCaloTrackReader.h
PWG/CaloTrackCorrBase/AliCalorimeterUtils.cxx
PWG/CaloTrackCorrBase/AliCalorimeterUtils.h
PWG/CaloTrackCorrBase/AliFiducialCut.cxx
PWG/CaloTrackCorrBase/AliFiducialCut.h
PWG/CaloTrackCorrBase/AliIsolationCut.cxx
PWG/CaloTrackCorrBase/AliIsolationCut.h
PWG/CaloTrackCorrBase/AliMCAnalysisUtils.cxx
PWG/CaloTrackCorrBase/AliMCAnalysisUtils.h
PWG/CaloTrackCorrBase/AliNeutralMesonSelection.cxx
PWG/CaloTrackCorrBase/AliNeutralMesonSelection.h
PWG/DevNanoAOD/AliAnalysisNanoAODCuts.cxx
PWG/DevNanoAOD/AliNanoAODHeader.h [deleted file]
PWG/EMCAL/AliAnalysisTaskEMCALClusterizeFast.cxx
PWG/EMCAL/AliAnalysisTaskEmcal.cxx
PWG/EMCAL/AliAnalysisTaskEmcal.h
PWG/EMCAL/AliClusterContainer.cxx
PWG/EMCAL/AliClusterContainer.h
PWG/EMCAL/AliEmcalContainer.cxx
PWG/EMCAL/AliEmcalContainer.h
PWG/EMCAL/AliEmcalPatchFromCellMaker.cxx [new file with mode: 0644]
PWG/EMCAL/AliEmcalPatchFromCellMaker.h [new file with mode: 0644]
PWG/EMCAL/AliEmcalPhysicsSelection.cxx
PWG/EMCAL/AliEmcalTriggerMaker.cxx
PWG/EMCAL/AliEmcalTriggerMaker.h
PWG/EMCAL/AliParticleContainer.cxx
PWG/EMCAL/AliParticleContainer.h
PWG/EMCAL/macros/AddTaskEmcalPatchFromCellMaker.C [new file with mode: 0644]
PWG/EMCAL/macros/AddTaskEmcalTriggerMaker.C
PWG/FLOW/Tasks/AliAnalysisTaskFlowEPCascade.cxx
PWG/FLOW/Tasks/AliAnalysisTaskFlowEventforRP.cxx
PWG/FLOW/Tasks/AliAnalysisTaskFlowStrange.cxx
PWG/FLOW/Tasks/AliAnalysisTaskPIDconfig.cxx [new file with mode: 0644]
PWG/FLOW/Tasks/AliAnalysisTaskPIDconfig.h [new file with mode: 0644]
PWG/FLOW/Tasks/AliAnalysisTaskPhiFlow.cxx
PWG/FLOW/Tasks/AliAnalysisTaskVnV0.cxx
PWG/FLOW/Tasks/AliFlowEvent.cxx
PWG/FLOW/Tasks/AliFlowEventCuts.cxx
PWG/FLOW/Tasks/AliFlowEventSimpleMaker.cxx
PWG/FLOW/Tasks/AliFlowTrackCuts.cxx
PWG/PWGDevNanoAODLinkDef.h
PWG/PWGEMCALLinkDef.h
PWG/PWGflowTasksLinkDef.h
PWG/muon/AliAODMuonReplicator.cxx
PWG/muon/AliAnalysisMuonUtility.cxx
PWG/muon/AliAnalysisTaskCreateMixedDimuons.cxx
PWG/muon/AliAnalysisTaskDimuonCFContainerBuilder.cxx
PWG/muon/AliAnalysisTaskESDMuonFilter.cxx
PWG/muon/AliAnalysisTaskLUT.cxx
PWG/muon/AliAnalysisTaskLinkToMC.cxx
PWG/muon/AliAnalysisTaskMuonAODCreation.cxx
PWG/muon/AliAnalysisTaskMuonAODfromGeneral.cxx
PWG/muon/AliAnalysisTaskMuonCollisionMultiplicity.cxx
PWG/muon/AliAnalysisTaskMuonDistributions.cxx
PWG/muon/AliAnalysisTaskSEMuonsHF.cxx
PWG/muon/AliAnalysisTaskSingleMuESD.cxx
PWG/muon/AliCFMuonResUpsilon.cxx
PWG/muon/AliCFMuonSingleTask1.cxx
PWGCF/CMakeLists.txt
PWGCF/CMakelibPWGCFCorrelationsDPhi.pkg
PWGCF/CMakelibPWGCFfemtoscopyUser.pkg
PWGCF/Correlations/Base/AliAnalyseLeadingTrackUE.cxx
PWGCF/Correlations/Base/AliAnalysisTaskCFTree.cxx
PWGCF/Correlations/DPhi/AliAnalysisTask3PCorrelations.cxx
PWGCF/Correlations/DPhi/AliAnalysisTaskContMC.cxx
PWGCF/Correlations/DPhi/AliAnalysisTaskDiHadron.cxx
PWGCF/Correlations/DPhi/AliAnalysisTaskDptDptCorrelations.cxx
PWGCF/Correlations/DPhi/AliAnalysisTaskDptDptQA.cxx
PWGCF/Correlations/DPhi/AliAnalysisTaskLongRangeCorrelations.cxx
PWGCF/Correlations/DPhi/AliAnalysisTaskMinijet.cxx
PWGCF/Correlations/DPhi/AliAnalysisTaskPhiCorrelations.cxx
PWGCF/Correlations/DPhi/AliAnalysisTaskTwoPlusOne.cxx
PWGCF/Correlations/DPhi/AliDptDptInMC.cxx
PWGCF/Correlations/DPhi/AliLeadingV0Correlation.cxx
PWGCF/Correlations/DPhi/DiHadronPID/AliAODEventCutsDiHadronPID.cxx
PWGCF/Correlations/DPhi/DiHadronPID/AliAnalysisTaskCompareAODTrackCuts.cxx
PWGCF/Correlations/DPhi/FourierDecomposition/AliDhcTask.cxx
PWGCF/Correlations/DPhi/FourierDecomposition/AliMuonEffMC.cxx
PWGCF/Correlations/DPhi/MuonHadron/AliAnalysisTaskDiMuonCorrelations.cxx
PWGCF/Correlations/DPhi/MuonHadron/AliAnalysisTaskMuonHadronCorrelations.cxx
PWGCF/Correlations/DPhi/PhiEffMC/AliAnalysisTaskPhiEffMc.cxx
PWGCF/Correlations/DPhi/PidPid/AliAnalysisTaskPidPidCorrelations.cxx
PWGCF/Correlations/DPhi/TriggerPID/AliAnalysisTaskPIDCORR.cxx
PWGCF/Correlations/DPhi/TriggerPID/AliTwoParticlePIDCorr.cxx
PWGCF/Correlations/DPhi/TriggerPID/AliTwoParticlePIDCorr.h
PWGCF/Correlations/DPhi/TriggerPID/AliTwoParticlePIDCorrKine.cxx [new file with mode: 0644]
PWGCF/Correlations/DPhi/TriggerPID/AliTwoParticlePIDCorrKine.h [new file with mode: 0644]
PWGCF/Correlations/JCORRAN/AliJBaseEventHeader.h
PWGCF/Correlations/JCORRAN/AliJCorrelations.cxx
PWGCF/Correlations/JCORRAN/AliJCorrelations.h
PWGCF/Correlations/JCORRAN/AliJFilter.cxx
PWGCF/Correlations/JCORRAN/AliJHistos.cxx
PWGCF/Correlations/JCORRAN/AliJHistos.h
PWGCF/Correlations/macros/TriggerPID/AddTaskTwoParticlePIDCorrKine.C [new file with mode: 0644]
PWGCF/Correlations/macros/dptdptcorrelations/AddTaskDptDptCorr_dca1.C
PWGCF/EBYE/BalanceFunctions/AliAnalysisTaskBF.cxx
PWGCF/EBYE/BalanceFunctions/AliAnalysisTaskEffContBF.cxx
PWGCF/EBYE/BalanceFunctions/AliAnalysisTaskEfficiencyBF.cxx
PWGCF/EBYE/BalanceFunctions/AliAnalysisTaskEfficiencyBFPsi.cxx
PWGCF/EBYE/BalanceFunctions/AliAnalysisTaskEventMixingBF.cxx
PWGCF/EBYE/BalanceFunctions/AliBalancePsi.cxx
PWGCF/EBYE/Fluctuations/AliAnalysisTaskChargeFluctuations.cxx
PWGCF/EBYE/Fluctuations/AliEbyEFluctuationAnalysisTask.cxx
PWGCF/EBYE/Fluctuations/AliEbyEFluctuationAnalysisTaskTrain.cxx
PWGCF/EBYE/Fluctuations/AliEbyEHigherMomentsEffContTask.cxx
PWGCF/EBYE/Fluctuations/AliEbyEHigherMomentsTask.cxx
PWGCF/EBYE/Fluctuations/AliEbyEHigherMomentsTaskPID.cxx
PWGCF/EBYE/Fluctuations/AliEbyEMultFluctuationTask.cxx
PWGCF/EBYE/Fluctuations/AliHigherMomentsToyModel.cxx
PWGCF/EBYE/LRC/AliAnalysisTaskLRC.cxx
PWGCF/EBYE/MeanPtFluctuations/AliAnalysisTaskPtFluc.cxx
PWGCF/EBYE/MeanPtFluctuations/AliAnalysisTaskPtFlucPbPb.cxx
PWGCF/EBYE/NetParticle/AliAnalysisNetParticleHelper.cxx
PWGCF/EBYE/NetParticle/AliAnalysisTaskNetParticle.cxx
PWGCF/EBYE/PIDFluctuation/task/AliEbyEParticleRatioFluctuationTask.cxx
PWGCF/EBYE/PIDFluctuation/task/AliEbyEPidRatioHelper.cxx
PWGCF/EBYE/PIDFluctuation/task/AliEbyEPidRatioTask.cxx
PWGCF/EBYE/PIDFluctuation/task/AliEbyEPidTTask.cxx
PWGCF/EBYE/PIDFluctuation/task/AliEbyEPidTTaskMC.cxx
PWGCF/EBYE/macros/drawBalanceFunction2DPsi.C
PWGCF/EBYE/macros/drawCorrelationFunctionPsi.C
PWGCF/FEMTOSCOPY/AliFemto/AliAnalysisTaskFemto.cxx
PWGCF/FEMTOSCOPY/AliFemto/AliFemtoCutMonitorParticlePID.cxx
PWGCF/FEMTOSCOPY/AliFemto/AliFemtoCutMonitorParticlePID.h
PWGCF/FEMTOSCOPY/AliFemto/AliFemtoCutMonitorV0.cxx
PWGCF/FEMTOSCOPY/AliFemto/AliFemtoCutMonitorV0.h
PWGCF/FEMTOSCOPY/AliFemto/AliFemtoEventReaderAOD.cxx
PWGCF/FEMTOSCOPY/AliFemto/AliFemtoEventReaderESDChainKine.cxx
PWGCF/FEMTOSCOPY/AliFemto/AliFemtoEventReaderStandard.cxx
PWGCF/FEMTOSCOPY/AliFemto/AliFemtoModelHiddenInfo.cxx
PWGCF/FEMTOSCOPY/AliFemto/AliFemtoModelHiddenInfo.h
PWGCF/FEMTOSCOPY/AliFemtoUser/AliAnalysisTaskParticleEfficiency.cxx
PWGCF/FEMTOSCOPY/AliFemtoUser/AliFemtoModelBPLCMSCorrFctnKK.cxx [new file with mode: 0644]
PWGCF/FEMTOSCOPY/AliFemtoUser/AliFemtoModelBPLCMSCorrFctnKK.h [new file with mode: 0644]
PWGCF/FEMTOSCOPY/Chaoticity/AliChaoticity.cxx
PWGCF/FEMTOSCOPY/Chaoticity/AliFourPion.cxx
PWGCF/FEMTOSCOPY/Chaoticity/AliThreePionRadii.cxx
PWGCF/FEMTOSCOPY/ESE/AliAnalysisTaskFemtoESE.cxx
PWGCF/FEMTOSCOPY/PLamAnalysis/AliAnalysisTaskProtonLambda.cxx
PWGCF/FEMTOSCOPY/UNICOR/AliUnicorEventAliceESD.h
PWGCF/FEMTOSCOPY/macros/Train/FemtoQA/PbPb/ConfigFemtoAnalysis.C [new file with mode: 0644]
PWGCF/FEMTOSCOPY/macros/Train/FemtoQA/PbPb_MC/ConfigFemtoAnalysis.C [new file with mode: 0644]
PWGCF/FEMTOSCOPY/macros/Train/FemtoQA/pPb/ConfigFemtoAnalysis.C [new file with mode: 0644]
PWGCF/FEMTOSCOPY/macros/Train/FemtoQA/pPb_MC/ConfigFemtoAnalysis.C [new file with mode: 0644]
PWGCF/FEMTOSCOPY/macros/Train/FemtoQA/pp/ConfigFemtoAnalysis.C [new file with mode: 0644]
PWGCF/FEMTOSCOPY/macros/Train/FemtoQA/pp_MC/ConfigFemtoAnalysis.C [new file with mode: 0644]
PWGCF/FEMTOSCOPYAOD/AliAnalysisTaskPWG2AODUpdate.cxx
PWGCF/FEMTOSCOPYAOD/AliAnalysisTaskPWG2ESDfilter.cxx
PWGCF/FLOW/CME/AliAnalysisTaskCMEv2A.cxx
PWGCF/FLOW/Documentation/examples/manual/ttree/macros/readTTree.C
PWGCF/PWGCFCorrelationsDPhiLinkDef.h
PWGCF/PWGCFfemtoscopyUserLinkDef.h
PWGDQ/CMakeLists.txt
PWGDQ/dielectron/AliAnalysisTaskDielectronFilter.cxx
PWGDQ/dielectron/AliAnalysisTaskReducedTree.cxx
PWGDQ/dielectron/AliDielectronEventCuts.cxx
PWGDQ/dielectron/AliDielectronVarManager.h
PWGDQ/dielectron/macrosJPSI/RaaPbPb2010/AliAnalysisTaskCorrelationTree.cxx
PWGGA/CMakeLists.txt
PWGGA/CMakelibPWGGAEMCALTasks.pkg
PWGGA/CMakelibPWGGAPHOSTasks.pkg
PWGGA/CaloTasks/AliAnalysisTaskCaloFilter.cxx
PWGGA/CaloTrackCorrelations/AliAnaCalorimeterQA.cxx
PWGGA/CaloTrackCorrelations/AliAnaCalorimeterQA.h
PWGGA/CaloTrackCorrelations/AliAnaChargedParticles.cxx
PWGGA/CaloTrackCorrelations/AliAnaChargedParticles.h
PWGGA/CaloTrackCorrelations/AliAnaClusterPileUp.cxx
PWGGA/CaloTrackCorrelations/AliAnaClusterPileUp.h
PWGGA/CaloTrackCorrelations/AliAnaEMCALTriggerClusters.cxx
PWGGA/CaloTrackCorrelations/AliAnaEMCALTriggerClusters.h
PWGGA/CaloTrackCorrelations/AliAnaElectron.cxx
PWGGA/CaloTrackCorrelations/AliAnaElectron.h
PWGGA/CaloTrackCorrelations/AliAnaGeneratorKine.cxx
PWGGA/CaloTrackCorrelations/AliAnaGeneratorKine.h
PWGGA/CaloTrackCorrelations/AliAnaInsideClusterInvariantMass.cxx
PWGGA/CaloTrackCorrelations/AliAnaInsideClusterInvariantMass.h
PWGGA/CaloTrackCorrelations/AliAnaOmegaToPi0Gamma.cxx
PWGGA/CaloTrackCorrelations/AliAnaParticleHadronCorrelation.cxx
PWGGA/CaloTrackCorrelations/AliAnaParticleHadronCorrelation.h
PWGGA/CaloTrackCorrelations/AliAnaParticleIsolation.cxx
PWGGA/CaloTrackCorrelations/AliAnaParticleIsolation.h
PWGGA/CaloTrackCorrelations/AliAnaParticleJetFinderCorrelation.cxx
PWGGA/CaloTrackCorrelations/AliAnaParticleJetFinderCorrelation.h
PWGGA/CaloTrackCorrelations/AliAnaParticleJetLeadingConeCorrelation.cxx
PWGGA/CaloTrackCorrelations/AliAnaParticleJetLeadingConeCorrelation.h
PWGGA/CaloTrackCorrelations/AliAnaParticlePartonCorrelation.cxx
PWGGA/CaloTrackCorrelations/AliAnaPhoton.cxx
PWGGA/CaloTrackCorrelations/AliAnaPhoton.h
PWGGA/CaloTrackCorrelations/AliAnaPhotonConvInCalo.cxx
PWGGA/CaloTrackCorrelations/AliAnaPhotonConvInCalo.h
PWGGA/CaloTrackCorrelations/AliAnaPi0.cxx
PWGGA/CaloTrackCorrelations/AliAnaPi0.h
PWGGA/CaloTrackCorrelations/AliAnaPi0EbE.cxx
PWGGA/CaloTrackCorrelations/AliAnaPi0EbE.h
PWGGA/CaloTrackCorrelations/AliAnaRandomTrigger.cxx
PWGGA/CaloTrackCorrelations/AliAnaRandomTrigger.h
PWGGA/CaloTrackCorrelations/macros/AddTaskCaloTrackCorr.C
PWGGA/CaloTrackCorrelations/macros/QA/AddTaskPi0IMGammaCorrQA.C
PWGGA/CaloTrackCorrelations/macros/QA/DrawAnaCaloTrackQA.C
PWGGA/EMCALTasks/AliAnalysisTaskEMCALClusterize.cxx
PWGGA/EMCALTasks/AliAnalysisTaskEMCALClusterize.h
PWGGA/EMCALTasks/AliAnalysisTaskEMCALIsoPhoton.cxx
PWGGA/EMCALTasks/AliAnalysisTaskEMCALIsoPhoton.h
PWGGA/EMCALTasks/AliAnalysisTaskEMCALMesonGGSDM.cxx
PWGGA/EMCALTasks/AliAnalysisTaskEMCALMesonGGSDMpPb.cxx
PWGGA/EMCALTasks/AliAnalysisTaskEMCALPi0PbPb.cxx
PWGGA/GammaConv/AliAnalysisTaskGCPartToPWG4Part.cxx
PWGGA/GammaConv/AliAnalysisTaskGCPartToPWG4Part.h
PWGGA/GammaConv/AliAnalysisTaskGammaCalo.cxx
PWGGA/GammaConv/AliAnalysisTaskGammaConvCalo.cxx
PWGGA/GammaConv/AliAnalysisTaskGammaConvCalo.h
PWGGA/GammaConv/AliAnalysisTaskGammaConvDalitzV1.cxx
PWGGA/GammaConv/AliAnalysisTaskGammaConvDalitzV1.h
PWGGA/GammaConv/AliAnalysisTaskGammaConvV1.cxx
PWGGA/GammaConv/AliCaloPhotonCuts.cxx
PWGGA/GammaConv/AliCaloPhotonCuts.h
PWGGA/GammaConv/AliConvEventCuts.cxx
PWGGA/GammaConv/AliConvEventCuts.h
PWGGA/GammaConv/AliConversionCuts.cxx
PWGGA/GammaConv/macros/AddTask_GammaCalo_pp.C
PWGGA/GammaConv/macros/AddTask_GammaConvCalo_PbPb.C
PWGGA/GammaConv/macros/AddTask_GammaConvCalo_pPb.C
PWGGA/GammaConv/macros/AddTask_GammaConvCalo_pp.C
PWGGA/GammaConv/macros/AddTask_GammaConvDalitzQAV1_pPb.C
PWGGA/GammaConv/macros/AddTask_GammaConvDalitzV1_pPb.C
PWGGA/GammaConv/macros/AddTask_GammaConvV1_PbPb.C
PWGGA/GammaConv/macros/AddTask_GammaConvV1_pp.C
PWGGA/GammaConv/macros/AddTask_GammaConvV1_pp2.C
PWGGA/PHOSTasks/PHOS_Tagging/AliAnalysisTaskTaggedPhotons.cxx
PWGGA/PHOSTasks/PHOS_embedding/AliAnalysisTaskPi0DiffEfficiency.cxx
PWGGA/PHOSTasks/PHOS_embedding/AliAnalysisTaskPi0Efficiency.cxx
PWGGA/PHOSTasks/PHOS_embedding/AliPHOSEmbedding.cxx
PWGHF/CMakeLists.txt
PWGHF/correlationHF/AliAnalysisTaskDStarCorrelations.cxx
PWGHF/correlationHF/AliAnalysisTaskDxHFECorrelation.cxx
PWGHF/correlationHF/AliAnalysisTaskSED0Correlations.cxx
PWGHF/correlationHF/AliAnalysisTaskSEHFCJqa.cxx
PWGHF/correlationHF/AliDxHFECorrelation.cxx
PWGHF/correlationHF/AliHFCorrelator.cxx
PWGHF/hfe/AliAnalysisTaskEMCalHFEpA.cxx
PWGHF/hfe/AliAnalysisTaskFlowITSTPCTOFQCSP.cxx
PWGHF/hfe/AliAnalysisTaskFlowTPCEMCalEP.cxx
PWGHF/hfe/AliAnalysisTaskFlowTPCEMCalQCSP.cxx
PWGHF/hfe/AliAnalysisTaskFlowTPCTOFEPSP.cxx
PWGHF/hfe/AliAnalysisTaskHFE.cxx
PWGHF/hfe/AliAnalysisTaskHFEemcQA.cxx
PWGHF/hfe/AliAnalysisTaskHFEemcQA.h
PWGHF/hfe/AliHFEpidObject.cxx
PWGHF/hfe/AliHFEpidObject.h
PWGHF/hfe/AliHFEpidTPC.cxx
PWGHF/hfe/AliHFEpidTPC.h
PWGHF/hfe/AliHFEtpcPIDqa.cxx
PWGHF/hfe/macros/AddTaskFlowTPCEMCalEP.C
PWGHF/hfe/macros/AddTaskHFEFlowTPCTOFEPSP.C
PWGHF/hfe/macros/AddTaskHFEemcQA.C
PWGHF/hfe/macros/configs/PbPb/CentCorrMapsTPC.root
PWGHF/hfe/macros/configs/PbPb/ConfigHFE_FLOW_TOFTPC.C
PWGHF/hfe/macros/configs/PbPb/EtaCorrMapsTPC.root
PWGHF/hfe/macros/configs/PbPb/jpsietacentcorr2_2011.root [new file with mode: 0644]
PWGHF/hfe/macros/configs/PbPb/jpsietacentcorr3_2011.root [new file with mode: 0644]
PWGHF/vertexingHF/AliAnalysisTaskCheckHFMCProd.cxx
PWGHF/vertexingHF/AliAnalysisTaskCombinHF.cxx
PWGHF/vertexingHF/AliAnalysisTaskSEBkgLikeSignD0.cxx
PWGHF/vertexingHF/AliAnalysisTaskSECharmFraction.cxx
PWGHF/vertexingHF/AliAnalysisTaskSED0Mass.cxx
PWGHF/vertexingHF/AliAnalysisTaskSEDStarSpectra.cxx
PWGHF/vertexingHF/AliAnalysisTaskSEDplus.cxx
PWGHF/vertexingHF/AliAnalysisTaskSEDs.cxx
PWGHF/vertexingHF/AliAnalysisTaskSEDvsMultiplicity.cxx
PWGHF/vertexingHF/AliAnalysisTaskSEDvsMultiplicity.h
PWGHF/vertexingHF/AliAnalysisTaskSEHFQA.cxx
PWGHF/vertexingHF/AliAnalysisTaskSEImproveITS.cxx
PWGHF/vertexingHF/AliAnalysisTaskSELambdac.cxx
PWGHF/vertexingHF/AliAnalysisTaskSELc2V0bachelor.cxx
PWGHF/vertexingHF/AliAnalysisTaskSELc2V0bachelor.h
PWGHF/vertexingHF/AliAnalysisTaskSELc2V0bachelorTMVA.cxx
PWGHF/vertexingHF/AliAnalysisTaskSELc2V0bachelorTMVA.h
PWGHF/vertexingHF/AliAnalysisTaskSESelectHF.cxx
PWGHF/vertexingHF/AliAnalysisVertexingHF.cxx
PWGHF/vertexingHF/AliCFTaskVertexingHF.cxx
PWGHF/vertexingHF/AliCFTaskVertexingHF.h
PWGHF/vertexingHF/AliCFVertexingHF.cxx
PWGHF/vertexingHF/AliCFVertexingHFCascade.cxx
PWGHF/vertexingHF/AliCFVertexingHFCascade.h
PWGHF/vertexingHF/AliRDHFCuts.cxx
PWGHF/vertexingHF/AliRDHFCutsLctoV0.cxx
PWGHF/vertexingHF/AliRDHFCutsLctoV0.h
PWGHF/vertexingHF/AliVertexingHFUtils.cxx
PWGHF/vertexingHF/AliVertexingHFUtils.h
PWGHF/vertexingHF/macros/AddTaskCFVertexingHFLctoV0bachelorTMVA.C
PWGHF/vertexingHF/macros/AddTaskDvsMultiplicity.C
PWGHF/vertexingHF/macros/AddTaskLc2V0bachelor.C
PWGHF/vertexingHF/macros/ReadDvsMultiplicity.C
PWGHF/vertexingHF/macros/makeTFile4CutsLctoV0bachelor.C
PWGJE/AliAnalysisTaskAj.cxx
PWGJE/AliAnalysisTaskFragmentationFunction.cxx
PWGJE/AliAnalysisTaskJetCore.cxx
PWGJE/AliAnalysisTaskJetCorePP.cxx
PWGJE/AliAnalysisTaskJetCorePP.h
PWGJE/AliAnalysisTaskJetProperties.cxx
PWGJE/AliAnalysisTaskJetServices.cxx
PWGJE/AliAnalysisTaskJetSpectrum2.cxx
PWGJE/AliAnalysisTaskJetsTM.cxx
PWGJE/AliAnalysisTaskPartonDisc.cxx
PWGJE/AliPWG4HighPtSpectra.cxx
PWGJE/AliPWG4HighPtTrackQA.cxx
PWGJE/CMakeLists.txt
PWGJE/CMakelibPWGJEEMCALJetTasks.pkg
PWGJE/EMCALJetTasks/AliAnalysisTaskDeltaPt.cxx
PWGJE/EMCALJetTasks/AliAnalysisTaskDeltaPt.h
PWGJE/EMCALJetTasks/AliEmcalJetTask.cxx
PWGJE/EMCALJetTasks/AliEmcalPicoTrackInGridMaker.cxx [new file with mode: 0644]
PWGJE/EMCALJetTasks/AliEmcalPicoTrackInGridMaker.h [new file with mode: 0644]
PWGJE/EMCALJetTasks/AliJetContainer.cxx
PWGJE/EMCALJetTasks/AliJetContainer.h
PWGJE/EMCALJetTasks/AliJetEmbeddingFromGenTask.cxx
PWGJE/EMCALJetTasks/AliJetModelBaseTask.h
PWGJE/EMCALJetTasks/AliJetResponseMaker.cxx
PWGJE/EMCALJetTasks/AliJetResponseMaker.h
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskCLQA.cxx
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskDcalDijetPerf.cxx
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskDcalDijetPerf.h
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskDijetHadron.cxx
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskDijetHadron.h
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskEmcalHighMultTrigger.cxx [new file with mode: 0644]
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskEmcalHighMultTrigger.h [new file with mode: 0644]
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskEmcalJetHadEPpid.cxx
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskEmcalQGTagging.cxx
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskEmcalQGTagging.h
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskJetMatching.cxx
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskJetMatching.h
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskPtEMCalTrigger.cxx
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskPtEMCalTrigger.h
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskSAJF.cxx
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskSAJF.h
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskV0sInJetsEmcal.cxx
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskV0sInJetsEmcal.h
PWGJE/EMCALJetTasks/macros/AddTaskDcalDijetPerf.C
PWGJE/EMCALJetTasks/macros/AddTaskDijetHadron.C
PWGJE/EMCALJetTasks/macros/AddTaskEmcalHighMultTrigger.C [new file with mode: 0644]
PWGJE/EMCALJetTasks/macros/AddTaskGridMaker.C [new file with mode: 0644]
PWGJE/EMCALJetTasks/macros/AddTaskV0sInJetsEmcal.C
PWGJE/FlavourJetTasks/AliAnalysisTaskEmcalJetHF.cxx
PWGJE/FlavourJetTasks/AliAnalysisTaskFlavourJetCorrelations.cxx
PWGJE/FlavourJetTasks/macros/AddTaskDFilterAndCorrelations.C
PWGJE/PWGJEEMCALJetTasksLinkDef.h
PWGJE/StrangenessInJets/AliAnalysisTaskJetChem.cxx
PWGJE/StrangenessInJets/AliAnalysisTaskV0sInJets.cxx
PWGJE/UserTasks/AliAnalysisTaskIDFFTCF.cxx
PWGJE/UserTasks/AliAnalysisTaskIDFragmentationFunction.cxx
PWGJE/UserTasks/AliAnalysisTaskJetAntenna.cxx
PWGJE/UserTasks/AliAnalysisTaskJetHBOM.cxx
PWGJE/UserTasks/AliAnalysisTaskJetProtonCorr.cxx
PWGJE/UserTasks/AliAnalysisTaskJetShape.cxx
PWGJE/UserTasks/AliAnalysisTaskPPJetSpectra.cxx
PWGLF/CMakeLists.txt
PWGLF/FORWARD/analysis2/AliBasedNdetaTask.cxx
PWGLF/FORWARD/analysis2/AliCopyHeaderTask.cxx
PWGLF/FORWARD/photons/AliAnalysisTaskPMD.cxx
PWGLF/FORWARD/photons/AliAnalysisTaskPMDSim.cxx
PWGLF/QATasks/AliAnalysisTaskQAHighPtDeDx.cxx
PWGLF/RESONANCES/AliRsnCutPrimaryVertex.cxx
PWGLF/RESONANCES/AliRsnEvent.cxx
PWGLF/RESONANCES/AliRsnMiniAnalysisTask.cxx
PWGLF/RESONANCES/extra/AliAnalysisTaskResonanceQA.cxx
PWGLF/RESONANCES/extra/AliAnalysisTaskSigma1385.cxx
PWGLF/RESONANCES/extra/AliRsnAnalysisPhi7TeV.cxx
PWGLF/RESONANCES/extra/AliRsnAnalysisPhi900GeV.cxx
PWGLF/RESONANCES/extra/AliXiStar.cxx
PWGLF/RESONANCES/macros/mini/AddAnalysisTaskD0.C
PWGLF/RESONANCES/macros/mini/ConfigD0.C
PWGLF/RESONANCES/macros/mini/ConfigTPCanalysisKStar.C
PWGLF/RESONANCES/macros/mini/ConfigTPCanalysisKStarMC.C
PWGLF/SPECTRA/AntiprotonToProton/AliProtonAnalysisBase.cxx
PWGLF/SPECTRA/AntiprotonToProton/AliProtonQAAnalysis.cxx
PWGLF/SPECTRA/ChargedHadrons/dNdPt/AlidNdPtAnalysis.cxx
PWGLF/SPECTRA/ChargedHadrons/dNdPt/AlidNdPtAnalysisPbPb.cxx
PWGLF/SPECTRA/ChargedHadrons/dNdPt/AlidNdPtAnalysisPbPb2011.cxx
PWGLF/SPECTRA/ChargedHadrons/dNdPt/AlidNdPtAnalysisPbPbAOD.cxx
PWGLF/SPECTRA/ChargedHadrons/dNdPt/AlidNdPtAnalysisPbPbAOD.h
PWGLF/SPECTRA/ChargedHadrons/dNdPt/AlidNdPtAnalysispPb.cxx
PWGLF/SPECTRA/ChargedHadrons/dNdPt/AlidNdPtCorrection.cxx
PWGLF/SPECTRA/ChargedHadrons/dNdPt/AlidNdPtCutAnalysis.cxx
PWGLF/SPECTRA/ChargedHadrons/dNdPt/AlidNdPtCutAnalysisPbPb.cxx
PWGLF/SPECTRA/ChargedHadrons/dNdPt/AlidNdPtEventCuts.cxx
PWGLF/SPECTRA/ChargedHadrons/dNdPt/AlidNdPtTrackDumpTask.cxx
PWGLF/SPECTRA/IdentifiedHighPt/train/AliAnalysisTaskHighPtDeDx.cxx
PWGLF/SPECTRA/Nuclei/B2/AliAnalysisTaskB2AOD.cxx
PWGLF/SPECTRA/Nuclei/PtSpectra/AliAnalysisAntiNuclei.cxx
PWGLF/SPECTRA/Nuclei/deuteronpA/AliAnalysisDeuteronpA.cxx
PWGLF/SPECTRA/PiKaPr/ITSsa/AliAnalysisTaskSEITSsaSpectra.cxx
PWGLF/SPECTRA/PiKaPr/TOF/pp7/AliAnalysisCombinedHadronSpectra2MC.cxx
PWGLF/SPECTRA/PiKaPr/TOF/pp7/TOFSpectrappAnalysis.cxx
PWGLF/SPECTRA/PiKaPr/TPC/pp900/AliAnalysisTaskChargedHadronSpectra.cxx
PWGLF/SPECTRA/PiKaPr/TPCTOF/AliAnalysisCombinedHadronSpectra.cxx
PWGLF/SPECTRA/PiKaPr/TPCTOFpA/AliAnalysisTPCTOFpA.cxx
PWGLF/SPECTRA/PiKaPr/TestAOD/AliAnalysisTaskSpectraAOD.cxx
PWGLF/SPECTRA/PiKaPr/TestAOD/AliAnalysisTaskSpectraAllChAOD.cxx
PWGLF/SPECTRA/PiKaPr/TestAOD/AliAnalysisTaskSpectraAllChAOD.h
PWGLF/SPECTRA/PiKaPr/TestAOD/AliAnalysisTaskV2AllChAOD.cxx
PWGLF/SPECTRA/PiKaPr/TestAOD/AliAnalysisTaskV2AllChAOD.h
PWGLF/SPECTRA/PiKaPr/TestAOD/AliSpectraAODEventCuts.cxx
PWGLF/SPECTRA/PiKaPr/TestAOD/AliSpectraAODEventCuts.h
PWGLF/SPECTRA/PiKaPr/TestAOD/AliSpectraBothEventCuts.cxx
PWGLF/SPECTRA/PiKaPr/TestAOD/AnalysisBoth.C
PWGLF/SPECTRA/XtAnalysis/AliXtAnalysis.cxx
PWGLF/STRANGENESS/Cascades/AliAnalysisTaskCheckCascadePbPb.cxx
PWGLF/STRANGENESS/Cascades/AliAnalysisTaskCheckPerformanceCascadePbPb.cxx
PWGLF/STRANGENESS/Cascades/AliAnalysisTaskStrangenessVsMultiplicityMC.cxx
PWGLF/STRANGENESS/Cascades/AliAnalysisTaskStrangenessVsMultiplicityMC.h
PWGLF/STRANGENESS/Correlations/AliAnalysisTaskLambdaOverK0sJets.cxx
PWGLF/STRANGENESS/Correlations/AliAnalysisTaskLambdaOverK0sJets.h
PWGLF/STRANGENESS/Correlations/AliAnalysisTaskV0ChCorrelations.cxx
PWGLF/STRANGENESS/Correlations/macros/AddTaskLambdaOverK0sJets.C
PWGLF/STRANGENESS/Hypernuclei/AliAODMCNuclExReplicator.cxx
PWGLF/STRANGENESS/Hypernuclei/AliAODNuclExReplicator.cxx
PWGLF/STRANGENESS/Hypernuclei/AliAnalysisTaskAntiHe4.cxx
PWGLF/STRANGENESS/Hypernuclei/AliAnalysisTaskHdibaryonLPpi.cxx
PWGLF/STRANGENESS/Hypernuclei/AliAnalysisTaskHelium3Pi.cxx
PWGLF/STRANGENESS/Hypernuclei/AliAnalysisTaskHelium3PiMC.cxx
PWGLF/STRANGENESS/Hypernuclei/AliAnalysisTaskLambdaNAOD.cxx
PWGLF/STRANGENESS/Hypernuclei/AliAnalysisTaskNucleiv2.cxx
PWGLF/STRANGENESS/Hypernuclei/AliAnalysisTaskNucleiv2SP.cxx
PWGLF/STRANGENESS/Hypernuclei/AliAnalysisTaskReadNuclexAOD.cxx
PWGLF/STRANGENESS/LambdaK0PbPb/AliAnalysisTaskCTauPbPb.cxx
PWGLF/STRANGENESS/LambdaK0PbPb/AliAnalysisTaskCTauPbPbaod.cxx
PWGLF/STRANGENESS/LambdaK0PbPb/AliAnalysisTaskLukeV0.cxx
PWGLF/STRANGENESS/LambdaK0PbPb/AliAnalysisTaskV0ForRAA.cxx
PWGPP/AliAnaVZEROQA.cxx
PWGPP/AliAnalysisTaskFilteredTree.cxx
PWGPP/AliAnalysisTaskIPInfo.cxx
PWGPP/AliFilteredTreeEventCuts.cxx
PWGPP/AliIntSpotEstimator.cxx
PWGPP/CMakeLists.txt
PWGPP/CMakelibPWGPP.pkg
PWGPP/CMakelibPWGPPMUONdep.pkg
PWGPP/CalibMacros/CPass0/makeOCDB.C
PWGPP/CalibMacros/CPass0/mergeMakeOCDB.byComponent.sh
PWGPP/CalibMacros/CPass1/AddTOFAnalysisTaskCalibTree.C [new file with mode: 0644]
PWGPP/CalibMacros/CPass1/makeOCDB.C
PWGPP/CalibMacros/CPass1/mergeMakeOCDB.byComponent.sh
PWGPP/Centrality/AliAnalysisTaskHIMultCorr.cxx
PWGPP/EvTrkSelection/AliCFSingleTrackEfficiencyTask.cxx
PWGPP/ITS/AliAnalysisTaskITSTrackingCheck.cxx
PWGPP/ITS/AliAnalysisTaskSEImpParRes.cxx
PWGPP/ITS/AliMeanVertexCalibTask.cxx
PWGPP/MUON/dep/AliAnalysisTaskMuonFakes.cxx
PWGPP/MUON/lite/MakeTrend.C
PWGPP/MUON/lite/PlotMuonQA.C
PWGPP/QA/detectorQAscripts/EXAMPLE.sh.template
PWGPP/QA/detectorQAscripts/MU.sh
PWGPP/QA/detectorQAscripts/V0.sh [new file with mode: 0755]
PWGPP/QA/scripts/alienSync.conf
PWGPP/QA/scripts/runQA.sh
PWGPP/T0/AliT0AnalysisTaskQA.cxx
PWGPP/TOF/AliAnalysisTaskTOFqa.cxx
PWGPP/TOF/AliAnalysisTaskTOFqaID.cxx
PWGPP/TOF/trending/DrawTrendingTOFQA.C
PWGPP/TOF/trending/localMergeFiles.C [new file with mode: 0644]
PWGPP/TPC/AliPerformancePtCalib.cxx
PWGPP/TPC/AliPerformancePtCalibMC.cxx
PWGPP/TPC/AliPerformanceTPC.cxx
PWGPP/TPC/AliRecInfoMaker.cxx
PWGPP/TRD/AliTRDcheckESD.cxx
PWGPP/VZERO/AliAnaVZEROPbPb.cxx
PWGPP/VZERO/trending/DrawTrendingV0QA.C [new file with mode: 0755]
PWGPP/VZERO/trending/MakeTrendingV0QA.C [new file with mode: 0755]
PWGPP/analysisQA/README
PWGPP/analysisQA/processCFv2vsPt.C
PWGPP/analysisQA/processDrawAnaCaloTrackQA.C
PWGPP/analysisQA/processFemtoQA.C [new file with mode: 0644]
PWGPP/global/AliAnalysisTaskGlobalQA.cxx
PWGPP/global/AliAnalysisTaskVertexESD.cxx
PWGPP/pid/AliAnalysisTaskK0sBayes.cxx
PWGPP/pid/AliAnalysisTaskLambdaBayes.cxx
PWGPP/pid/AliAnalysisTaskPhiBayes.cxx
PWGPP/pid/doeffKa.C
PWGPP/pid/doeffPi.C
PWGPP/pid/doeffPr.C
PWGUD/CMakeLists.txt
PWGUD/CMakelibPWGUDdiffractive.pkg
PWGUD/DIFFRACTIVE/QA/AddTaskCPQA.C [new file with mode: 0755]
PWGUD/DIFFRACTIVE/QA/AliAnalysisTaskCPQA.cxx [new file with mode: 0755]
PWGUD/DIFFRACTIVE/QA/AliAnalysisTaskCPQA.h [new file with mode: 0755]
PWGUD/DIFFRACTIVE/xsAndTwoProng/AliCDMesonTracks.cxx
PWGUD/PWGUDdiffractiveLinkDef.h
PWGUD/UPC/AliAnalysisTaskUpcK0sK0s.cxx
PWGUD/UPC/AliAnalysisTaskUpcPsi2s.cxx
PWGUD/UPC/AliAnalysisTaskUpcPsi2s.h
PWGUD/selectors/dNdEta/AlidNdEtaTask.cxx
PWGUD/selectors/multiplicity/AliMultiplicityTask.cxx
PYTHIA6/AliDecayerPythia.cxx
PYTHIA6/CMakeLists.txt
PYTHIA8/CMakeLists.txt
RAW/AliHoughFilter.cxx
RAW/AliRawEventHeaderBase.cxx
RAW/AliRawReaderDate.cxx
RAW/AliRawReaderDate.h
RAW/CMakeLists.txt
RAW/dateStream.cxx
SHUTTLE/CMakeLists.txt
STARLIGHT/AliGenStarLight.cxx
STARLIGHT/AliGenStarLight.h
STARLIGHT/AliStarLightLinkDef.h
STARLIGHT/CMakeLists.txt
STARLIGHT/CMakelibStarLight.pkg
STARLIGHT/starlight/CMakeLists.txt
STARLIGHT/starlight/Makefile
STARLIGHT/starlight/Readme
STARLIGHT/starlight/TStarLight/testsl.C
STARLIGHT/starlight/cmake_modules/FindROOT.cmake
STARLIGHT/starlight/config/slight.in
STARLIGHT/starlight/include/inputParameters.h
STARLIGHT/starlight/include/randomgenerator.h
STARLIGHT/starlight/src/gammaavm.cpp
STARLIGHT/starlight/src/gammagammaleptonpair.cpp
STARLIGHT/starlight/src/inputParameters.cpp
STARLIGHT/starlight/src/randomgenerator.cpp
STARLIGHT/starlight/src/starlight.cpp
STARLIGHT/starlight/utils/ana.C
STARLIGHT/starlight/utils/convertStarlightAsciiToTree.C
STARLIGHT/test/Config.C
STAT/CMakeLists.txt
STEER/AOD/AliAODEvent.cxx
STEER/AOD/AliAODEvent.h
STEER/AOD/AliAODHandler.cxx
STEER/AOD/AliAODHeader.cxx
STEER/AOD/AliAODHeader.h
STEER/AOD/AliAODInputHandler.cxx
STEER/AOD/AliAODPWG4Particle.cxx
STEER/AOD/AliAODPWG4Particle.h
STEER/AOD/AliAODPWG4ParticleCorrelation.cxx
STEER/AOD/AliAODPWG4ParticleCorrelation.h
STEER/AOD/AliAODTagCreator.cxx
STEER/AOD/AliAODTrack.cxx
STEER/AOD/AliAODTrack.h
STEER/AOD/AliAODZDC.cxx
STEER/AOD/AliNanoAODHeader.cxx [moved from PWG/DevNanoAOD/AliNanoAODHeader.cxx with 100% similarity]
STEER/AOD/AliNanoAODHeader.h [new file with mode: 0644]
STEER/AOD/AliNanoAODStorage.cxx [moved from PWG/DevNanoAOD/AliNanoAODStorage.cxx with 100% similarity]
STEER/AOD/AliNanoAODStorage.h [moved from PWG/DevNanoAOD/AliNanoAODStorage.h with 100% similarity]
STEER/AOD/AliNanoAODTrackMapping.cxx [moved from PWG/DevNanoAOD/AliNanoAODTrackMapping.cxx with 100% similarity]
STEER/AOD/AliNanoAODTrackMapping.h [moved from PWG/DevNanoAOD/AliNanoAODTrackMapping.h with 100% similarity]
STEER/AODLinkDef.h
STEER/AliVertexerTracksTest.C
STEER/CMakeLists.txt
STEER/CMakelibAOD.pkg
STEER/CMakelibSTEERBase.pkg
STEER/CreateAODfromKineTree.C
STEER/ESD/AliCascadeVertexer.cxx
STEER/ESD/AliESD.cxx
STEER/ESD/AliESDEvent.cxx
STEER/ESD/AliESDRun.cxx
STEER/ESD/AliESDZDC.h
STEER/ESD/AliESDtrack.h
STEER/ESD/AliV0vertexer.cxx
STEER/ESD/AliVertex.h
STEER/ESD/AliVertexerTracks.cxx
STEER/STEER/AliESDTagCreator.cxx
STEER/STEER/AliGlobalQADataMaker.cxx
STEER/STEER/AliReconstruction.cxx
STEER/STEERBase/AliPIDCombined.cxx
STEER/STEERBase/AliPIDResponse.cxx
STEER/STEERBase/AliTOFPIDResponse.cxx
STEER/STEERBase/AliTOFPIDResponse.h
STEER/STEERBase/AliVAODHeader.cxx [new file with mode: 0644]
STEER/STEERBase/AliVAODHeader.h [new file with mode: 0644]
STEER/STEERBase/AliVHeader.h
STEER/STEERBase/AliVVertex.h
STEER/STEERBaseLinkDef.h
STRUCT/CMakeLists.txt
T0/AliAnalysisTaskT0QA.cxx
T0/AliT0AnalysisTaskQA.cxx
T0/CMakeLists.txt
TAmpt/CMakeLists.txt
TDPMjet/CMakeLists.txt
TEPEMGEN/CMakeLists.txt
TEvtGen/CMakeLists.txt
THbtp/CMakeLists.txt
THerwig/CMakeLists.txt
THijing/CMakeLists.txt
TOF/AddTOFAnalysisTaskCalibTree.C [new file with mode: 0644]
TOF/AliTOFAnalysisTaskCalibTree.cxx [new file with mode: 0644]
TOF/AliTOFAnalysisTaskCalibTree.h [new file with mode: 0644]
TOF/CMakeLists.txt
TOF/CMakelibTOFcalib.pkg
TOF/TOFcalibLinkDef.h
TPC/AliL1Delay.C
TPC/CMakeLists.txt
TPC/TPCPEDESTALda.cxx
TPC/TPCPULSERda.cxx
TPC/fastSimul/AliTPCclusterFast.cxx
TPC/fastSimul/README.txt
TPC/fastSimul/simul.sh
TPHIC/CMakeLists.txt
TRD/AliTRDReconstructor.cxx
TRD/AliTRDclusterizer.cxx
TRD/CMakeLists.txt
TRD/CMakelibTRDbase.pkg
TRD/qaAnalysis/AliAnalysisTaskTRDmon.cxx
TRIGGER/CMakeLists.txt
TTherminator/CMakeLists.txt
TUHKMgen/CMakeLists.txt
VZERO/AliVZERODigitizer.cxx
VZERO/CMakeLists.txt
ZDC/AliZDCDigitizer.cxx
ZDC/AliZDCQADataMakerRec.cxx
ZDC/AliZDCRawStream.cxx
ZDC/AliZDCReconstructor.cxx
ZDC/AliZDCTriggerProcessor.cxx
ZDC/CMakeLists.txt
cmake/ALICE_CMake.cmake
cmake/CMakeDA.cmake
cmake/CMakelinux.cmake
cmake/CMakelinuxalphagcc.cmake
cmake/CMakelinuxia64gcc.cmake
cmake/CMakelinuxx8664gcc.cmake
cmake/CMakelinuxx8664icc.cmake
cmake/CMakemacosx64.cmake
cmake/FindAMORE.cmake
cmake/FindCPack.cmake
cmake/FindFASTJET.cmake
cmake/FindGEANT3.cmake
cmake/FindROOT.cmake
cmake/FindRuleChecker.cmake
cmake/Module.tmp
test/vmctest/scripts/efficiency/AliAnalysisTaskEfficiency.cxx

diff --git a/.DS_Store b/.DS_Store
new file mode 100644 (file)
index 0000000..240f978
Binary files /dev/null and b/.DS_Store differ
index aff82972cd5c178c266f6258a3e859e5e1cba298..01bed4fdc6928ac4fec08401c1efc355f537eae3 100644 (file)
@@ -3,7 +3,7 @@
 # Author: Johny Jose m(johny.jose@cern.ch)
 #         Port of previous Makefile build to cmake
 
-cmake_minimum_required(VERSION 2.8.4 FATAL_ERROR)
+cmake_minimum_required(VERSION 2.8.8 FATAL_ERROR)
 
 file(GLOB PACKAGES CMake*.pkg)
 
index 3373b22364f27ae5a63b7d24ff88d3d649a38933..2f52d9b89e8cbedc7650c61069a9f9096b675f40 100644 (file)
@@ -110,14 +110,14 @@ AliADCalibData* AliADQADataMakerRec::GetCalibData() const
 
   AliCDBEntry *entry=0;
 
-  entry = man->Get("AD/Calib/Data",fRun);
-  if(!entry){
-    AliWarning("Load of calibration data from default storage failed!");
-    AliWarning("Calibration data will be loaded from local storage ($ALICE_ROOT)");
+  //entry = man->Get("AD/Calib/Data",fRun);
+  //if(!entry){
+    //AliWarning("Load of calibration data from default storage failed!");
+    //AliWarning("Calibration data will be loaded from local storage ($ALICE_ROOT)");
        
     man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
     entry = man->Get("AD/Calib/Data",fRun);
-  }
+  //}
   // Retrieval of data in directory AD/Calib/Data:
 
   AliADCalibData *calibdata = 0;
@@ -220,14 +220,14 @@ void AliADQADataMakerRec::MakeDigits()
 }
 
 //____________________________________________________________________________
-void AliADQADataMakerRec::MakeDigits(TTree *digitTree)
+void AliADQADataMakerRec::MakeDigits(TTree* /*digitTree*/)
 {
 
 }
 
 
 //____________________________________________________________________________
-void AliADQADataMakerRec::MakeESDs(AliESDEvent * esd)
+void AliADQADataMakerRec::MakeESDs(AliESDEvent* /*esd*/)
 {
  
 }
@@ -477,10 +477,10 @@ void AliADQADataMakerRec::MakeRaws(AliRawReader* rawReader)
       // Fill HPTDC Time Histograms
       timeCorr[offlineCh] = CorrectLeadingTime(offlineCh,time[offlineCh],adc[offlineCh]);
 
-      const Float_t p1 = 2.50; // photostatistics term in the time resolution
-      const Float_t p2 = 3.00; // sleewing related term in the time resolution
+      //const Float_t p1 = 2.50; // photostatistics term in the time resolution
+      //const Float_t p2 = 3.00; // sleewing related term in the time resolution
       if(timeCorr[offlineCh]>-1024 + 1.e-6){
-       Float_t nphe = adc[offlineCh]*kChargePerADC/(fCalibData->GetGain(offlineCh)*TMath::Qe());
+       //Float_t nphe = adc[offlineCh]*kChargePerADC/(fCalibData->GetGain(offlineCh)*TMath::Qe());
        Float_t timeErr = 1;
        /*/
        if (nphe>1.e-6) timeErr = TMath::Sqrt(kIntTimeRes*kIntTimeRes+
@@ -592,7 +592,7 @@ void AliADQADataMakerRec::MakeRaws(AliRawReader* rawReader)
 }
 
 //____________________________________________________________________________ 
-Float_t AliADQADataMakerRec::CorrectLeadingTime(Int_t i, Float_t time, Float_t adc) const
+Float_t AliADQADataMakerRec::CorrectLeadingTime(Int_t /*i*/, Float_t time, Float_t /*adc*/) const
 {
   // Correct the leading time
   // for slewing effect and
index 16de35e58442b10df64dfb7ff55bf6bad4b30b62..f9e9b3d479f61376921d532a4007a213bfa99c83 100644 (file)
@@ -41,8 +41,8 @@ AliADRawStream::AliADRawStream(AliRawReader* rawReader) :
   // select the raw data corresponding to
   // the AD detector id
   fRawReader->Reset();
-  AliDebug(1,Form("Selecting raw data for detector %d",AliDAQ::DetectorID("AD")));
-  fRawReader->Select("AD");
+  AliDebug(1,Form("Selecting raw data for detector %d",AliDAQ::DetectorID("VZERO")));
+  fRawReader->Select("VZERO");
 
   // Initalize the containers
   for(Int_t i = 0; i < kNChannels; i++) {
@@ -106,9 +106,9 @@ Bool_t AliADRawStream::Next()
   if (!fRawReader->ReadNextData(fData)) return kFALSE;
   if (fRawReader->GetDataSize() == 0) return kFALSE;
      
-  if (fRawReader->GetDataSize() != 1568) {
-     fRawReader->AddFatalErrorLog(kRawDataSizeErr,Form("size %d != 1568",fRawReader->GetDataSize()));
-     AliWarning(Form("Wrong AD raw data size: %d, expected 1568 bytes!",fRawReader->GetDataSize()));
+  if (fRawReader->GetDataSize() != 5936) {
+     fRawReader->AddFatalErrorLog(kRawDataSizeErr,Form("size %d != 5936",fRawReader->GetDataSize()));
+     AliWarning(Form("Wrong AD raw data size: %d, expected 5936 bytes!",fRawReader->GetDataSize()));
      return kFALSE;
   }
 
@@ -122,8 +122,14 @@ Bool_t AliADRawStream::Next()
 
   for(Int_t iBunch = 0; iBunch < kNBunches; iBunch++)
      fBunchNumbers[iBunch] = GetNextWord();
-  for (Int_t  iCIU = 0; iCIU < kNCIUBoards; iCIU++) { 
+  
+  Int_t iCIU=0;
+  for (Int_t  iV0CIU = 0; iV0CIU < 8; iV0CIU++) {
+    
+    if(iV0CIU != 1 || iV0CIU != 5) {
+      for(Int_t iWord = 0; iWord<182; iWord++) GetNextWord();
+      continue;
+       }
  
   // decoding of one Channel Interface Unit numbered iCIU - there are 8 channels per CIU (and 2 CIUs) :
   
@@ -185,9 +191,9 @@ Bool_t AliADRawStream::Next()
       fTime[iChannel]  = time & 0xfff;
       fWidth[iChannel] = ((time >> 12) & 0x7f); // HPTDC used in pairing mode
     }
-    
+    iCIU++;
     // End of decoding of one CIU card
-    // printf("Number of bytes used at end of reading CIU card number %d %d \n\n", iCIU+1, fPosition); 
+    AliWarning(Form("Number of bytes used at end of reading CIU card number %d %d", iCIU+1, fPosition)); 
     
   } // end of decoding the eight CIUs
     
index 1ceac8337cfe3d9123aff6d3dcb2e9afa05fc2a2..c102723dd0cb6ee4057bb24b1018ee7f8d7df379 100644 (file)
 //                                                                          //
 //  Class for AD reconstruction                                         //
 //////////////////////////////////////////////////////////////////////////////
+#include <TParameter.h>
 
 #include "AliRawReader.h"
+#include "AliGRPObject.h"
+#include "AliCDBManager.h"
+#include "AliCDBStorage.h"
+#include "AliCDBEntry.h"
+#include "AliESDEvent.h"
 
 #include "AliADReconstructor.h"
-#include "AliESDEvent.h"
 #include "AliADdigit.h"
 #include "AliESDAD.h"
+#include "AliADConst.h"
+#include "AliADCalibData.h"
+#include "AliADRawStream.h"
 
 ClassImp(AliADReconstructor)
-
+//_____________________________________________________________________________
 AliADReconstructor:: AliADReconstructor():
   AliReconstructor(),
   fESDAD(0x0),
+  fCalibData(NULL),
   fDigitsArray(0)
+
 {
+  fCalibData = GetCalibData();
   // Default constructor  
   // Get calibration data
 
@@ -63,12 +74,71 @@ void AliADReconstructor::Init()
     fESDAD  = new AliESDAD;
 }
 
-void AliADReconstructor::ConvertDigits(AliRawReader* /*rawReader*/, TTree* /*digitsTree*/) const
+//_____________________________________________________________________________
+void AliADReconstructor::ConvertDigits(AliRawReader* rawReader, TTree* digitsTree) const
 {
+// converts RAW to digits 
+
+  if (!digitsTree) {
+    AliError("No digits tree!");
+    return;
+  }
+
+  if (!fDigitsArray){
+    fDigitsArray = new TClonesArray("AliADdigit", 16);
+    digitsTree->Branch("ADDigit", &fDigitsArray);
+    }
+
+  rawReader->Reset();
+  AliADRawStream rawStream(rawReader);
+  if (rawStream.Next()) { 
+
+    Int_t aBBflagsADA = 0;
+    Int_t aBBflagsADC = 0;
+    Int_t aBGflagsADA = 0;
+    Int_t aBGflagsADC = 0;
+
+    for(Int_t iChannel=0; iChannel < 16; ++iChannel) {
+      Int_t offlineCh = rawStream.GetOfflineChannel(iChannel);
+      // ADC charge samples
+      Short_t chargeADC[kNClocks];
+      for(Int_t iClock=0; iClock < kNClocks; ++iClock) {
+       chargeADC[iClock] = rawStream.GetPedestal(iChannel,iClock);
+      }
+      // Integrator flag
+      Bool_t integrator = rawStream.GetIntegratorFlag(iChannel,kNClocks/2);
+      // Beam-beam and beam-gas flags
+      if(offlineCh<8) {
+       if (rawStream.GetBBFlag(iChannel,kNClocks/2)) aBBflagsADC |= (1 << offlineCh);
+       if (rawStream.GetBGFlag(iChannel,kNClocks/2)) aBGflagsADC |= (1 << offlineCh);
+      } else {
+       if (rawStream.GetBBFlag(iChannel,kNClocks/2)) aBBflagsADA |= (1 << (offlineCh-32));
+       if (rawStream.GetBGFlag(iChannel,kNClocks/2)) aBGflagsADA |= (1 << (offlineCh-32));
+      }
+      // HPTDC data (leading time and width)
+      Int_t board = AliADCalibData::GetBoardNumber(offlineCh);
+      Float_t time = rawStream.GetTime(iChannel)*fCalibData->GetTimeResolution(board);
+      Float_t width = rawStream.GetWidth(iChannel)*fCalibData->GetWidthResolution(board);
+      // Add a digit
+      if(!fCalibData->IsChannelDead(iChannel)){
+         new ((*fDigitsArray)[fDigitsArray->GetEntriesFast()]) AliADdigit(offlineCh, time, width,integrator, chargeADC);
+      }
+    }
+    // Store the BB and BG flags in the digits tree (user info)
+    digitsTree->GetUserInfo()->Add(new TParameter<int>("BBflagsADA",aBBflagsADA));
+    digitsTree->GetUserInfo()->Add(new TParameter<int>("BBflagsADC",aBBflagsADC));
+    digitsTree->GetUserInfo()->Add(new TParameter<int>("BGflagsADA",aBGflagsADA));
+    digitsTree->GetUserInfo()->Add(new TParameter<int>("BGflagsADC",aBGflagsADC));
+
+
+    digitsTree->Fill();
+  }
+
+  fDigitsArray->Clear();
 
-  printf("Converting digits for AD .. not implemented \n");
 }
 
+//_____________________________________________________________________________
 void AliADReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/,AliESDEvent* esd) const
 {
 
@@ -117,4 +187,30 @@ void AliADReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/,AliE
   fDigitsArray->Clear();
 }
 
+//_____________________________________________________________________________
+AliADCalibData* AliADReconstructor::GetCalibData() const
+{
+  AliCDBManager *man = AliCDBManager::Instance();
+
+  AliCDBEntry *entry=0;
+
+  //entry = man->Get("AD/Calib/Data");
+  //if(!entry){
+    //AliWarning("Load of calibration data from default storage failed!");
+    //AliWarning("Calibration data will be loaded from local storage ($ALICE_ROOT)");
+       
+    man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
+    man->SetRun(1);
+    entry = man->Get("AD/Calib/Data");
+  //}
+  // Retrieval of data in directory AD/Calib/Data:
+
+  AliADCalibData *calibdata = 0;
+
+  if (entry) calibdata = (AliADCalibData*) entry->GetObject();
+  if (!calibdata)  AliFatal("No calibration data from calibration database !");
+
+  return calibdata;
+}
+
 
index 10248502e7ed8d6fed54038c6482c00710cf7d2d..14711b3b9d49ad885a87304322ef09e3fcb87a1b 100644 (file)
 
 #include "AliReconstructor.h"
 #include "AliLog.h"
+#include "AliADConst.h"
 
 class AliESDAD;
 class AliESDEvent;
+class AliADCalibData;
 
 class AliADReconstructor: public AliReconstructor {
 public:
@@ -37,16 +39,17 @@ public:
   virtual Bool_t HasDigitConversion() const { return kTRUE; }
   virtual void ConvertDigits(AliRawReader* rawReader, TTree* digitsTree) const;
 
+  AliADCalibData *GetCalibData() const; 
 
 protected:
 
   AliESDAD*        fESDAD;      // AD ESD object  
 
 private:
-  AliADReconstructor(const AliADReconstructor&); //Not implemented
-  AliADReconstructor& operator = (const AliADReconstructor&); //Not implemented
+  AliADReconstructor(const AliADReconstructor &reconstructor); //Not implemented
+  AliADReconstructor& operator = (const AliADReconstructor &reconstructor); //Not implemented
   
-
+  AliADCalibData* fCalibData;      //! calibration data
   mutable TClonesArray *fDigitsArray;  // clones-array for ConvertDigits() and FillESD()
 
   ClassDef(AliADReconstructor, 1)  // class for the AD reconstruction
index 4d031269629eccebae6d2f293d98ec738b4c7257..cfad82fb723a9378e3573e8147ba77e09c2a6501 100644 (file)
@@ -58,8 +58,16 @@ fIntegrator(integrator)
   if (labels)
     for(Int_t iTrack = 0; iTrack < 3; ++iTrack) fTracks[iTrack] = labels[iTrack];
 }
-
-
+//__________________________________________________________________________
+Bool_t AliADdigit::GetIntegratorFlag(Int_t clock)
+{
+if (clock >= 0 && clock < kNClocks){
+       if(clock%2 == 0) return fIntegrator;
+       else return !fIntegrator;
+       }
+       
+else return kFALSE;
+}
 //__________________________________________________________________________
 void AliADdigit::Print(const Option_t*) const
 {
index ab567881b8559327ad150f3577ee73269abc7ec9..38a61a1de5ca4b55f52743f8335e92f7ce2ff015 100644 (file)
@@ -27,6 +27,7 @@ public:
     Float_t Width()      const {return fWidth;} 
     Bool_t  Integrator() const {return fIntegrator;}
     Short_t ChargeADC(Int_t clock) const {return (clock >= 0 && clock < kNClocks) ? fChargeADC[clock] : 0;}
+    Bool_t  GetIntegratorFlag(Int_t clock);
     
   protected:
     Int_t   fPMNumber;      // PhotoMultiplier number (0 to 16)
index dec0c580d6b00e2f7c6221dbb9b1c9e0cf4678fd..7c9bc8b22aa67d094ff5392bbec459e1e8d8da6b 100644 (file)
@@ -3,7 +3,7 @@
 # Author: Johny Jose m(johny.jose@cern.ch)
 #         Port of previous Makefile build to cmake
 
-cmake_minimum_required(VERSION 2.8.4 FATAL_ERROR)
+cmake_minimum_required(VERSION 2.8.8 FATAL_ERROR)
 
 file(GLOB PACKAGES CMake*.pkg)
 
index 3859667da68fd59267cbae208ce6ccf118f9ec43..f470f64ba244dcd5ea22a4bc0ac47c27ad3740f7 100644 (file)
@@ -3,7 +3,7 @@
 # Author: Johny Jose m(johny.jose@cern.ch)
 #         Port of previous Makefile build to cmake
 
-cmake_minimum_required(VERSION 2.8.4 FATAL_ERROR)
+cmake_minimum_required(VERSION 2.8.8 FATAL_ERROR)
 
 file(GLOB PACKAGES CMake*.pkg)
 
index 2e68503b4a804304e4a8504ab04f09b5056d4dc7..7b8c04a885592f9affd8843aef159d7e2bc84125 100644 (file)
@@ -834,7 +834,9 @@ void AliAnalysisTaskPIDqa::FillTPCqa()
 
   // Get reference multiplicity for AODs
   if ( analysisType == "AOD" && fAODevent ) {
-    mult=fAODevent->GetHeader()->GetTPConlyRefMultiplicity();
+    AliAODHeader * header=dynamic_cast<AliAODHeader*>(fAODevent->GetHeader());
+    if(!header) AliFatal("Not a standard AOD");
+    mult=header->GetTPConlyRefMultiplicity();
   }
 
   /*if (mult < 0) {
index 074bdb390357d8d27078e28bae72a257d34ec204..34b2610d606ba91e64034ccedfb2858ee3ef2685 100644 (file)
@@ -55,7 +55,7 @@
 ClassImp(AliAnalysisTaskSE)
 
 ////////////////////////////////////////////////////////////////////////
-AliAODHeader*    AliAnalysisTaskSE::fgAODHeader         = NULL;
+AliVHeader*      AliAnalysisTaskSE::fgAODHeader         = NULL;
 AliTOFHeader*    AliAnalysisTaskSE::fgTOFHeader         = NULL;
 AliAODVZERO*     AliAnalysisTaskSE::fgAODVZERO          = NULL;
 TClonesArray*    AliAnalysisTaskSE::fgAODTracks         = NULL;
index e66753d07fb3c20c8774b9b794b58e1b86c42894..78aaaafd4668fc2163998bd3d062605a9c6d1e74 100644 (file)
@@ -88,7 +88,7 @@ class AliAnalysisTaskSE : public AliAnalysisTask
     // Output histos for QA
     TList*                fHistosQA;        //! Output histos for QA
     // Provisions for replication
-    static AliAODHeader*    fgAODHeader;        //! Header for replication
+    static AliVHeader*      fgAODHeader;        //! Header for replication
     static AliTOFHeader*    fgTOFHeader;        //! TOFHeader for replication
     static AliAODVZERO*     fgAODVZERO;         //! VZERO for replication
     static TClonesArray*    fgAODTracks;        //! Tracks for replication
index 8890165bc7b1bb1609a49e7a6f58e49131625bfb..15fef1d74d790c569be83fc2d1e99c70e2a99469 100644 (file)
@@ -114,7 +114,8 @@ Bool_t AliAnalysisUtils::IsFirstEventInChunk(AliVEvent *event)
 
   if(fisAOD){
     AliAODHeader *aodheader = 0x0;
-    aodheader = aod->GetHeader();
+    aodheader = dynamic_cast<AliAODHeader*>(aod->GetHeader());
+    if(!aodheader) AliFatal("Not a standard AOD");
     if(!aodheader){
       AliFatal("AOD header not there ?!");
       return kFALSE;
@@ -216,11 +217,11 @@ Bool_t AliAnalysisUtils::IsOutOfBunchPileUp(AliVEvent *event)
     AliFatal("Event is neither of AOD nor ESD type");
     return kFALSE;
   }
-  Int_t bc2 = (aod)?aod->GetHeader()->GetIRInt2ClosestInteractionMap():esd->GetHeader()->GetIRInt2ClosestInteractionMap();
+  Int_t bc2 = (aod)?((AliVAODHeader*)aod->GetHeader())->GetIRInt2ClosestInteractionMap():esd->GetHeader()->GetIRInt2ClosestInteractionMap();
   if (bc2 != 0)
     return kTRUE;
   
-  Int_t bc1 = (aod)?aod->GetHeader()->GetIRInt1ClosestInteractionMap():esd->GetHeader()->GetIRInt1ClosestInteractionMap();
+  Int_t bc1 = (aod)?((AliVAODHeader*)aod->GetHeader())->GetIRInt1ClosestInteractionMap():esd->GetHeader()->GetIRInt1ClosestInteractionMap();
   if (bc1 != 0)
     return kTRUE;
   
index bb06834bdefa358dd21e432ebd464bd92b0e4832..ee1e960c2d75ab48b2b4dd75d738ac4e47a31881 100644 (file)
@@ -1444,7 +1444,8 @@ void AliCentralitySelectionTask::UserExec(Option_t */*option*/)
     //nTracks    = event->GetNumberOfTracks();     
     nTracks    = fTrackCuts ? (Short_t)fTrackCuts->GetReferenceMultiplicity(esd,kTRUE):-1;
   } else {
-    AliAODHeader *h = aod->GetHeader();
+    AliAODHeader *h = dynamic_cast<AliAODHeader*>(aod->GetHeader());
+    if(!h) AliFatal("Not a standard AOD");
     nTracks    = h!=0 ? (Short_t)h->GetTPConlyRefMultiplicity():-1;
   }
 
@@ -1468,7 +1469,8 @@ void AliCentralitySelectionTask::UserExec(Option_t */*option*/)
     Short_t nTrTPCcandle = 0;
     for (Int_t iTracks = 0; iTracks < aod->GetNumberOfTracks(); iTracks++) {
 
-      AliAODTrack* track = aod->GetTrack(iTracks);
+      AliAODTrack* track = dynamic_cast<AliAODTrack*>(aod->GetTrack(iTracks));
+      if(!track) AliFatal("Not a standard AOD");
 
       if (!track) continue;
       if (!track->TestFilterBit(1<<5) && 
@@ -1493,7 +1495,8 @@ void AliCentralitySelectionTask::UserExec(Option_t */*option*/)
   } else {
     AliAODTracklets *mult = aod->GetTracklets();
     nTracklets = mult->GetNumberOfTracklets();
-    AliAODHeader *h = aod->GetHeader();
+    AliAODHeader *h = dynamic_cast<AliAODHeader*>(aod->GetHeader());
+    if(!h) AliFatal("Not a standard AOD");
     for(Int_t ilay=0; ilay<6; ilay++){
       nClusters[ilay] = h->GetNumberOfITSClusters(ilay);
     }
@@ -1580,7 +1583,8 @@ void AliCentralitySelectionTask::UserExec(Option_t */*option*/)
     if (zpcFired) zpcTower = ZPCtower[0];
 
   } else {
-    AliAODHeader *h = aod->GetHeader();
+    AliAODHeader *h = dynamic_cast<AliAODHeader*>(aod->GetHeader());
+    if(!h) AliFatal("Not a standard AOD");
     zncEnergy  = (Float_t) (h->GetZDCN1Energy());
     zpcEnergy  = (Float_t) (h->GetZDCP1Energy());
     znaEnergy  = (Float_t) (h->GetZDCN2Energy());
index 601035b61be0cf64ddf3a4d00f37c5ee795093ba..df7e5914fd79222e7c5d5db0ece8a34a8e5734e6 100644 (file)
@@ -347,7 +347,8 @@ void AliEPSelectionTask::UserExec(Option_t */*option*/)
     if (aod){
 
       // get centrality of the event
-      AliAODHeader *header=aod->GetHeader();
+      AliAODHeader *header=dynamic_cast<AliAODHeader*>(aod->GetHeader());
+      if(!header) AliFatal("Not a standard AOD");
       AliCentrality *centrality=header->GetCentralityP();
       if(!centrality)  AliError(Form("No AliCentrality attached to AOD header"));
       fCentrality = centrality->GetCentralityPercentile("V0M");
@@ -365,7 +366,7 @@ void AliEPSelectionTask::UserExec(Option_t */*option*/)
        if (headerH) fRP = headerH->GetReactionPlaneAngle();
       }
   
-      esdEP = aod->GetHeader()->GetEventplaneP();
+      esdEP = header->GetEventplaneP();
       if(!esdEP) return; // protection against missing EP branch (nanoAODs)
       esdEP->Reset(); 
      
@@ -417,7 +418,8 @@ void AliEPSelectionTask::UserExec(Option_t */*option*/)
          }
        }
        
-       AliAODTrack* trmax = aod->GetTrack(0);
+       AliAODTrack* trmax = dynamic_cast<AliAODTrack*>(aod->GetTrack(0));
+       if(!trmax) AliFatal("Not a standard AOD");
        for (int iter = 1; iter<NT;iter++){
          AliAODTrack* track = dynamic_cast<AliAODTrack*> (tracklist->At(iter));
          if (track && (track->Pt() > trmax->Pt())) trmax = track;
@@ -881,7 +883,8 @@ TObjArray* AliEPSelectionTask::GetAODTracksAndMaxID(AliAODEvent* aod, Int_t& max
   Int_t ntpc = fESDtrackCuts->GetMinNClusterTPC(); 
   
   for (Int_t i = 0; i < aod->GetNumberOfTracks() ; i++){
-     tr = aod->GetTrack(i);
+     tr = dynamic_cast<AliAODTrack*>(aod->GetTrack(i));
+     if(!tr) AliFatal("Not a standard AOD");
      maxidtemp = tr->GetID(); 
      if(maxidtemp < 0 && fAODfilterbit != 128) continue;
      if(maxidtemp > -1 && fAODfilterbit == 128) continue;
index fc6e185dc2441c3dc8f8f934face92457f2c713c..5df8b5384278784eb5f2bdf5d3c507a3c0fa5de1 100644 (file)
@@ -132,36 +132,36 @@ using std::endl;
 ClassImp(AliPhysicsSelection)
 
 AliPhysicsSelection::AliPhysicsSelection() :
-  AliAnalysisCuts("AliPhysicsSelection", "AliPhysicsSelection"),
-  fPassName(""),
-  fCurrentRun(-1),
-  fMC(kFALSE),
-  fCollTrigClasses(),
-  fBGTrigClasses(),
-  fTriggerAnalysis(),
+AliAnalysisCuts("AliPhysicsSelection", "AliPhysicsSelection"),
+fPassName(""),
+fCurrentRun(-1),
+fMC(kFALSE),
+fCollTrigClasses(),
+fBGTrigClasses(),
+fTriggerAnalysis(),
 //  fHistStatisticsTokens(0),
-  fHistBunchCrossing(0),
-  fHistTriggerPattern(0),
-  fSkipTriggerClassSelection(0),
-  fUsingCustomClasses(0),
-  fSkipV0(0),
-  fBIFactorA(-1),
-  fBIFactorC(-1),
-  fBIFactorAC(-1), 
-  fComputeBG(0),
-  fBGStatOffset(-1),
-  fUseBXNumbers(1),
-  fUseMuonTriggers(0),
-  fFillingScheme(""),
-  fBin0CallBack(""),
-  fBin0CallBackPointer(0),
-  fIsPP(kFALSE),
-  fPSOADB(0),
-  fFillOADB(0),
-  fTriggerOADB(0),
-  fRegexp(0),
-  fCashedTokens(0)
-  
+fHistBunchCrossing(0),
+fHistTriggerPattern(0),
+fSkipTriggerClassSelection(0),
+fUsingCustomClasses(0),
+fSkipV0(0),
+fBIFactorA(-1),
+fBIFactorC(-1),
+fBIFactorAC(-1), 
+fComputeBG(0),
+fBGStatOffset(-1),
+fUseBXNumbers(1),
+fUseMuonTriggers(0),
+fFillingScheme(""),
+fBin0CallBack(""),
+fBin0CallBackPointer(0),
+fIsPP(kFALSE),
+fPSOADB(0),
+fFillOADB(0),
+fTriggerOADB(0),
+fRegexp(0),
+fCashedTokens(0)
+
 {
   // constructor
   
@@ -177,15 +177,15 @@ AliPhysicsSelection::AliPhysicsSelection() :
   
   AliLog::SetClassDebugLevel("AliPhysicsSelection", AliLog::kWarning);
 }
-    
+
 AliPhysicsSelection::~AliPhysicsSelection()
 {
   // destructor
-
+  
   fCollTrigClasses.Delete();
   fBGTrigClasses.Delete();
   fTriggerAnalysis.Delete();
-
+  
   if (fHistStatistics[0])
   {
     delete fHistStatistics[0];
@@ -210,7 +210,7 @@ AliPhysicsSelection::~AliPhysicsSelection()
     delete fHistTriggerPattern;
     fHistTriggerPattern = 0;
   }
-
+  
   if (fPSOADB)
   { 
     delete fPSOADB;
@@ -232,14 +232,14 @@ AliPhysicsSelection::~AliPhysicsSelection()
     delete fRegexp;
     fRegexp = 0;
   }
-    
+  
   if (fCashedTokens)
   {
     delete fCashedTokens;
     fCashedTokens = 0;
   }
-
-
+  
+  
 }
 
 UInt_t AliPhysicsSelection::CheckTriggerClass(const AliESDEvent* aEsd, const char* trigger, Int_t& triggerLogic) const
@@ -302,7 +302,7 @@ UInt_t AliPhysicsSelection::CheckTriggerClass(const AliESDEvent* aEsd, const cha
     else if (str2[0] == '#')
     {
       foundBCRequirement = kTRUE;
-    
+      
       str2.Remove(0, 1);
       
       Int_t bcNumber = str2.Atoi();
@@ -341,14 +341,14 @@ UInt_t AliPhysicsSelection::CheckTriggerClass(const AliESDEvent* aEsd, const cha
 //______________________________________________________________________________
 TObject *AliPhysicsSelection::GetStatistics(const Option_t *option) const
 {
-// Get the statistics histograms ("ALL" and "BIN0" and "TOK")
-   TString opt(option);
-   opt.ToUpper();
-   Int_t ihist = 0;
-   if (opt == "ALL") ihist = kStatIdxAll;
-   if (opt == "BIN0") ihist = kStatIdxBin0;
-   //   if (opt == "TOK") return fHistStatisticsTokens;
-   return fHistStatistics[ihist];
+  // Get the statistics histograms ("ALL" and "BIN0" and "TOK")
+  TString opt(option);
+  opt.ToUpper();
+  Int_t ihist = 0;
+  if (opt == "ALL") ihist = kStatIdxAll;
+  if (opt == "BIN0") ihist = kStatIdxBin0;
+  //   if (opt == "TOK") return fHistStatisticsTokens;
+  return fHistStatistics[ihist];
 }   
 
 //______________________________________________________________________________
@@ -367,10 +367,10 @@ Bool_t AliPhysicsSelection::EvaluateTriggerLogic(const AliESDEvent* aEsd, AliTri
     
     TArrayI pos;
     Int_t nMatches = fRegexp->Match(trigger, "", 0, 2, &pos);
-
+    
     if (nMatches <= 0)
       break;
-      
+    
     TString token(trigger(pos[0], pos[1]-pos[0]+1));
     
     TParameter<Int_t>* param = (TParameter<Int_t>*) fCashedTokens->FindObject(token);
@@ -399,7 +399,7 @@ Bool_t AliPhysicsSelection::EvaluateTriggerLogic(const AliESDEvent* aEsd, AliTri
       //      if(fHistStatisticsTokens)              
     }
   }
-
+  
   TFormula formula("formula", trigger);
   if (formula.Compile() > 0)
     AliFatal(Form("Could not evaluate trigger logic %s (evaluated to %s)", triggerLogic, trigger.Data()));
@@ -423,7 +423,7 @@ UInt_t AliPhysicsSelection::IsCollisionCandidate(const AliESDEvent* aEsd)
   } 
   mgr->LoadBranch("AliESDHeader.");
   mgr->LoadBranch("AliESDRun.");
-
+  
   if (fCurrentRun != aEsd->GetRunNumber()) {
     if (!Initialize(aEsd))
       AliFatal(Form("Could not initialize for run %d", aEsd->GetRunNumber()));
@@ -449,7 +449,7 @@ UInt_t AliPhysicsSelection::IsCollisionCandidate(const AliESDEvent* aEsd)
   }
   
   mgr->LoadBranch("AliMultiplicity.");
-//mgr->LoadBranch("AliESDFMD.");
+  //mgr->LoadBranch("AliESDFMD.");
   mgr->LoadBranch("AliESDVZERO.");
   mgr->LoadBranch("AliESDZDC.");
   mgr->LoadBranch("SPDVertex.");
@@ -457,9 +457,9 @@ UInt_t AliPhysicsSelection::IsCollisionCandidate(const AliESDEvent* aEsd)
   mgr->LoadBranch("TPCVertex.");
   mgr->LoadBranch("Tracks");
   mgr->LoadBranch("SPDPileupVertices");
-
+  
   UInt_t accept = 0;
-    
+  
   Int_t count = fCollTrigClasses.GetEntries() + fBGTrigClasses.GetEntries();
   for (Int_t i=0; i < count; i++)
   {
@@ -468,11 +468,11 @@ UInt_t AliPhysicsSelection::IsCollisionCandidate(const AliESDEvent* aEsd)
       triggerClass = ((TObjString*) fCollTrigClasses.At(i))->String();
     else
       triggerClass = ((TObjString*) fBGTrigClasses.At(i - fCollTrigClasses.GetEntries()))->String();
-  
+    
     AliDebug(AliLog::kDebug+1, Form("Processing trigger class %s", triggerClass));
-  
+    
     AliTriggerAnalysis* triggerAnalysis = static_cast<AliTriggerAnalysis*> (fTriggerAnalysis.At(i));
-  
+    
     triggerAnalysis->FillTriggerClasses(aEsd);
     
     Int_t triggerLogic = 0; 
@@ -481,12 +481,12 @@ UInt_t AliPhysicsSelection::IsCollisionCandidate(const AliESDEvent* aEsd)
     if (singleTriggerResult)
     {
       triggerAnalysis->FillHistograms(aEsd);
-  
+      
       Bool_t isBin0 = kFALSE;
       if (fBin0CallBack != "") {
-         isBin0 = ((AliAnalysisTaskSE*)mgr->GetTask(fBin0CallBack.Data()))->IsEventInBinZero();
+        isBin0 = ((AliAnalysisTaskSE*)mgr->GetTask(fBin0CallBack.Data()))->IsEventInBinZero();
       } else if (fBin0CallBackPointer) {
-         isBin0 = (*fBin0CallBackPointer)(aEsd);
+        isBin0 = (*fBin0CallBackPointer)(aEsd);
       }
       
       // ---->
@@ -494,10 +494,10 @@ UInt_t AliPhysicsSelection::IsCollisionCandidate(const AliESDEvent* aEsd)
       // tables. Decide wethere we are switching to a new stat table
       // (with all AliTriggerAnalysis tokens? Only we the tokens
       // actually used in the selection?) and clean up
-
+      
       AliESDVZERO *esdV0 = aEsd->GetVZEROData();
       if(!esdV0) fSkipV0 = kTRUE;
-
+      
       // hardware trigger
       Int_t fastORHW   = triggerAnalysis->EvaluateTrigger(aEsd, AliTriggerAnalysis::kSPDGFO); // SPD number of chips from trigger bits (!)
       //      Int_t fastORHWL1 = triggerAnalysis->EvaluateTrigger(aEsd, AliTriggerAnalysis::kSPDGFOL1); // SPD number of chips from trigger bits in second layer (!)
@@ -515,12 +515,12 @@ UInt_t AliPhysicsSelection::IsCollisionCandidate(const AliESDEvent* aEsd)
       Bool_t t0       = triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kT0    ));
       Bool_t t0BG     = triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kT0BG    ));
       Bool_t t0PileUp = triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kT0Pileup));
-
+      
       // fmd
       // Bool_t fmdA = triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kFMDA));
       // Bool_t fmdC = triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kFMDC));
       // Bool_t fmd  = fmdA || fmdC;
-    
+      
       // SSD
       //Int_t ssdClusters = triggerAnalysis->SSDClusters(aEsd);
       
@@ -532,14 +532,14 @@ UInt_t AliPhysicsSelection::IsCollisionCandidate(const AliESDEvent* aEsd)
       Bool_t zdcTime = triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kZDCTime));
       Bool_t znABG   = triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kZNABG));
       Bool_t znCBG   = triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kZNCBG));
-
+      
       Bool_t laserCut = triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kTPCLaserWarmUp));
       Bool_t hvDipCut = triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kTPCHVdip));
-
+      
       // Some "macros"
       Bool_t mb1 = (fastOROffline > 0 || v0A || v0C) && (!v0BG);
       Bool_t mb1prime = (fastOROffline > 1 || (fastOROffline > 0 && (v0A || v0C)) || (v0A && v0C) ) && (!v0BG);
-
+      
       // Background rejection
       Bool_t bgID = kFALSE;
       bgID = triggerAnalysis->EvaluateTrigger(aEsd,  (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kSPDClsVsTrkBG | AliTriggerAnalysis::kOfflineFlag)); // FIXME: temporarily, we keep both ways to validate the new one. if the external BG id is not set, it will use the new one
@@ -549,17 +549,17 @@ UInt_t AliPhysicsSelection::IsCollisionCandidate(const AliESDEvent* aEsd)
       if(v0C)              ntrig += 1; //v0C alone is enough
       if(fmd)              ntrig += 1;
       if(ssdClusters>1)    ntrig += 1;*/
-
+      
       // // EMCAL offline trigger validation
       // Bool_t emcCut = triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kEMCAL));
       
       // <---
-
+      
       TString triggerLogicOnline  = fPSOADB->GetHardwareTrigger(triggerLogic);
       TString triggerLogicOffline = fPSOADB->GetOfflineTrigger(triggerLogic);
-
+      
       AliDebug(AliLog::kDebug, Form("Triggers from OADB [0x%x][%d][%s][%s]",singleTriggerResult,AliOADBPhysicsSelection::GetActiveBit(singleTriggerResult),triggerLogicOffline.Data(),triggerLogicOnline.Data()));
-
+      
       // replay hardware trigger (should only remove events for MC)
       Bool_t onlineTrigger  = EvaluateTriggerLogic(aEsd, triggerAnalysis, triggerLogicOnline, kFALSE);
       // offline selection
@@ -567,124 +567,79 @@ UInt_t AliPhysicsSelection::IsCollisionCandidate(const AliESDEvent* aEsd)
       
       // Printf("%s %s", triggerLogicOnline.Data(), triggerLogicOffline.Data());
       // Printf("%d %d", onlineTrigger, offlineTrigger);
-          
-
+      
+      
       // Fill trigger pattern histo
       Int_t tpatt = 0;
       if (fastORHW>0) tpatt+=1;
       if (v0AHW)      tpatt+=2;
       if (v0CHW)      tpatt+=4;
       fHistTriggerPattern->Fill( tpatt );
-
+      
       // fill statistics and return decision
       const Int_t nHistStat = 2;
       for(Int_t iHistStat = 0; iHistStat < nHistStat; iHistStat++){
-       if (iHistStat == kStatIdxBin0 && !isBin0) continue; // skip the filling of bin0 stats if the event is not in the bin0
-      
-       fHistStatistics[iHistStat]->Fill(kStatTriggerClass, i);
-       if(iHistStat == kStatIdxAll) fHistBunchCrossing->Fill(aEsd->GetBunchCrossNumber(), i); // Fill only for all (avoid double counting)
-
-       // We fill the rest only if hw trigger is ok
-       if (!onlineTrigger)
-         {
-           AliDebug(AliLog::kDebug, "Rejecting event because hardware trigger is not fired");
-           continue;
-         } else {       
-         fHistStatistics[iHistStat]->Fill(kStatHWTrig, i);
-       }
-      
-
-       // v0 BG stats
-       if (v0ABG)
-         fHistStatistics[iHistStat]->Fill(kStatV0ABG, i);
-       if (v0CBG)
-         fHistStatistics[iHistStat]->Fill(kStatV0CBG, i);
-
-       // T0 stats
-       if(t0)
-         fHistStatistics[iHistStat]->Fill(kStatT0BB,     i);
-       if(t0BG)
-         fHistStatistics[iHistStat]->Fill(kStatT0BG,     i);
-       if(t0PileUp)
-         fHistStatistics[iHistStat]->Fill(kStatT0PileUp, i);
-
-       // mb 1
-       if (mb1)
-         fHistStatistics[iHistStat]->Fill(kStatMB1, i);
-
-       if (mb1prime)
-         fHistStatistics[iHistStat]->Fill(kStatMB1Prime, i);
-
-       if (laserCut)
-         fHistStatistics[iHistStat]->Fill(kStatLaserCut, i);
-
-       if (hvDipCut)
-         fHistStatistics[iHistStat]->Fill(kHVdipCut, i);
-
-       //if(ntrig >= 2 && !v0BG) 
-       //  fHistStatistics[iHistStat]->Fill(kStatAny2Hits, i);
-
-       if (fastOROffline > 0)
-         fHistStatistics[iHistStat]->Fill(kStatFO1, i);
-       if (fastOROffline > 1)
-         fHistStatistics[iHistStat]->Fill(kStatFO2, i);
-       if (fastOROfflineL1 > 1)
-         fHistStatistics[iHistStat]->Fill(kStatFO2L1, i);
+        if (iHistStat == kStatIdxBin0 && !isBin0) continue; // skip the filling of bin0 stats if the event is not in the bin0
         
-       if (v0A)
-         fHistStatistics[iHistStat]->Fill(kStatV0A, i);
-       if (v0C)
-         fHistStatistics[iHistStat]->Fill(kStatV0C, i);
-         
-       if (zdcA)
-         fHistStatistics[iHistStat]->Fill(kStatZDCA, i);
-       if (zdcC)
-         fHistStatistics[iHistStat]->Fill(kStatZDCC, i);
-       if (zdcA && zdcC)
-         fHistStatistics[iHistStat]->Fill(kStatZDCAC, i);
-
-       if (zdcTime)
-         fHistStatistics[iHistStat]->Fill(kStatZDCTime, i);
-       if (znABG)
-         fHistStatistics[iHistStat]->Fill(kStatZNABG, i);
-       if (znCBG)
-         fHistStatistics[iHistStat]->Fill(kStatZNCBG, i);
-  
-       if (v0A && v0C && !v0BG && (!bgID && fIsPP))
-         fHistStatistics[iHistStat]->Fill(kStatV0, i);
-
-       if (v0A && v0C && !v0BG && (!bgID && fIsPP) && !znABG && !znCBG)
-         fHistStatistics[iHistStat]->Fill(kStatV0ZN, i);
-
-       if (bgID && !v0BG) 
-         fHistStatistics[iHistStat]->Fill(kStatBG, i);
-
-       // FIXME: check lines below
-       if ( offlineTrigger )
-         {
-           if (!v0BG || fSkipV0)
-             {
-               if (!v0BG) fHistStatistics[iHistStat]->Fill(kStatOffline, i);
-               AliDebug(AliLog::kDebug, Form("Accepted event for histograms with trigger logic %d", triggerLogic));
+        fHistStatistics[iHistStat]->Fill(kStatTriggerClass, i);
+        if(iHistStat == kStatIdxAll) fHistBunchCrossing->Fill(aEsd->GetBunchCrossNumber(), i); // Fill only for all (avoid double counting)
+        
+        // We fill the rest only if hw trigger is ok
+        if (!onlineTrigger) {
+          AliDebug(AliLog::kDebug, "Rejecting event because hardware trigger is not fired");
+          continue;
+        } else {
+          fHistStatistics[iHistStat]->Fill(kStatHWTrig, i);
+        }
+        
+        if (v0ABG)               fHistStatistics[iHistStat]->Fill(kStatV0ABG, i);
+        if (v0CBG)               fHistStatistics[iHistStat]->Fill(kStatV0CBG, i);
+        if (t0)                  fHistStatistics[iHistStat]->Fill(kStatT0BB,     i);
+        if (t0BG)                fHistStatistics[iHistStat]->Fill(kStatT0BG,     i);
+        if (t0PileUp)            fHistStatistics[iHistStat]->Fill(kStatT0PileUp, i);
+        if (mb1)                 fHistStatistics[iHistStat]->Fill(kStatMB1, i);
+        if (mb1prime)            fHistStatistics[iHistStat]->Fill(kStatMB1Prime, i);
+        if (laserCut)            fHistStatistics[iHistStat]->Fill(kStatLaserCut, i);
+        if (hvDipCut)            fHistStatistics[iHistStat]->Fill(kHVdipCut, i);
+        if (fastOROffline > 0)   fHistStatistics[iHistStat]->Fill(kStatFO1, i);
+        if (fastOROffline > 1)   fHistStatistics[iHistStat]->Fill(kStatFO2, i);
+        if (fastOROfflineL1 > 1) fHistStatistics[iHistStat]->Fill(kStatFO2L1, i);
+        if (v0A)                 fHistStatistics[iHistStat]->Fill(kStatV0A, i);
+        if (v0C)                 fHistStatistics[iHistStat]->Fill(kStatV0C, i);
+        if (zdcA)                fHistStatistics[iHistStat]->Fill(kStatZDCA, i);
+        if (zdcC)                fHistStatistics[iHistStat]->Fill(kStatZDCC, i);
+        if (zdcA && zdcC)        fHistStatistics[iHistStat]->Fill(kStatZDCAC, i);
+        if (zdcTime)             fHistStatistics[iHistStat]->Fill(kStatZDCTime, i);
+        if (znABG)               fHistStatistics[iHistStat]->Fill(kStatZNABG, i);
+        if (znCBG)               fHistStatistics[iHistStat]->Fill(kStatZNCBG, i);
+        if (bgID && !v0BG)       fHistStatistics[iHistStat]->Fill(kStatBG, i);
+        if (v0A && v0C && !v0BG && (!bgID && fIsPP)) fHistStatistics[iHistStat]->Fill(kStatV0, i);
+        if (v0A && v0C && !v0BG && (!bgID && fIsPP) && !znABG && !znCBG) fHistStatistics[iHistStat]->Fill(kStatV0ZN, i);
+        
+        // FIXME: check lines below
+        if ( offlineTrigger ) {
+          if (!v0BG || fSkipV0) {
+            if (!v0BG) fHistStatistics[iHistStat]->Fill(kStatOffline, i);
+            AliDebug(AliLog::kDebug, Form("Accepted event for histograms with trigger logic %d", triggerLogic));
+            
+            fHistStatistics[iHistStat]->Fill(kStatAccepted, i);
+            
+            if (aEsd->IsPileupFromSPD())
+              fHistStatistics[iHistStat]->Fill(kStatAcceptedPileUp, i);
             
-               fHistStatistics[iHistStat]->Fill(kStatAccepted, i);
-               
-               if (aEsd->IsPileupFromSPD())
-                 fHistStatistics[iHistStat]->Fill(kStatAcceptedPileUp, i);
-               
-                   // if(iHistStat == kStatIdxAll) fHistBunchCrossing->Fill(aEsd->GetBunchCrossNumber(), i); // Fill only for all (avoid double counting)
-               if((i < fCollTrigClasses.GetEntries() || fSkipTriggerClassSelection) && (iHistStat==kStatIdxAll))
-                 accept |= singleTriggerResult; // only set for "all" (should not really matter)
-             }
-           else
-             AliDebug(AliLog::kDebug, "Rejecting event because of V0 BG flag");
-         }
-       else
-         AliDebug(AliLog::kDebug, Form("Rejecting event because trigger logic %d is not fulfilled", triggerLogic));
+            // if(iHistStat == kStatIdxAll) fHistBunchCrossing->Fill(aEsd->GetBunchCrossNumber(), i); // Fill only for all (avoid double counting)
+            if((i < fCollTrigClasses.GetEntries() || fSkipTriggerClassSelection) && (iHistStat==kStatIdxAll))
+              accept |= singleTriggerResult; // only set for "all" (should not really matter)
+          }
+          else
+            AliDebug(AliLog::kDebug, "Rejecting event because of V0 BG flag");
+        }
+        else
+          AliDebug(AliLog::kDebug, Form("Rejecting event because trigger logic %d is not fulfilled", triggerLogic));
       }
     }
   }
+  
   if (accept)
     AliDebug(AliLog::kDebug, Form("Accepted event as collision candidate with bit mask %d", accept));
   
@@ -848,7 +803,7 @@ UInt_t AliPhysicsSelection::IsCollisionCandidate(const AliESDEvent* aEsd)
 //     else if (!strcmp("CINT1C-ABCE-NOPF-ALL",trigger)) return "   #3019  #3119  #3219  #3319  #3519 ";
 //     else if (!strcmp("CINT1-E-NOPF-ALL",trigger)) return " #1835 #2726";
 //     //    else AliError(Form("Unknown trigger: %s", trigger));
-    
+
 //   } 
 //   else if (runNumber >= 130148 && runNumber <= 130375) {
 //     TString triggerString = trigger;
@@ -887,25 +842,25 @@ Bool_t AliPhysicsSelection::Initialize(const AliESDEvent* aEsd)
   fIsPP = kTRUE;
   if (strcmp(aEsd->GetESDRun()->GetBeamType(), "A-A") == 0)
     fIsPP = kFALSE;
-
+  
   return Initialize(aEsd->GetRunNumber());
 }
 
 Bool_t AliPhysicsSelection::Initialize(Int_t runNumber)
 {
   // initializes the object for the given run  
-
-
+  
+  
   Bool_t oldStatus = TH1::AddDirectoryStatus();
   TH1::AddDirectory(kFALSE);
-
+  
   /// Open OADB file and fetch OADB objects
   TString oadbfilename = AliPhysicsSelection::GetOADBFileName();
-
+  
   TFile * foadb = TFile::Open(oadbfilename);
   if(!foadb->IsOpen()) AliFatal(Form("Cannot open OADB file %s", oadbfilename.Data()));
-
-
+  
+  
   if(!fPSOADB || !fUsingCustomClasses) { // if it's already set and custom class is required, we use the one provided by the user
     AliInfo("Using Standard OADB");
     AliOADBContainer * psContainer = (AliOADBContainer*) foadb->Get("physSel");
@@ -928,17 +883,17 @@ Bool_t AliPhysicsSelection::Initialize(Int_t runNumber)
     fTriggerOADB->Print();
     if (!fTriggerOADB) AliFatal(Form("Cannot find  trigger analysis object for run %d", runNumber));
   }
-
+  
   
   if(!fBin0CallBack) 
     AliError("Bin0 Callback not set: will not fill the statistics for the bin 0");
-
+  
   if (fMC) {
     // override BX and bg options in case of MC
     fComputeBG    = kFALSE;
     fUseBXNumbers = kFALSE;
   }
-
+  
   // FIXME: think how to implement this check with the OADB, trigger scheme is not a int number here 
   // Int_t triggerScheme = GetTriggerScheme(runNumber);
   // if (!fUsingCustomClasses && fCurrentRun != -1 && triggerScheme != GetTriggerScheme(fCurrentRun))
@@ -946,15 +901,15 @@ Bool_t AliPhysicsSelection::Initialize(Int_t runNumber)
   
   if(fComputeBG && fCurrentRun != -1 && fCurrentRun != runNumber) 
     AliFatal("Cannot process several runs because BG computation is requested");
-
+  
   if(fComputeBG && !fUseBXNumbers) 
     AliFatal("Cannot compute BG if BX numbers are not used");
   
   if(fUseBXNumbers && fFillingScheme != "" && fFillingScheme != fFillOADB->GetFillingSchemeName())
     AliFatal("Cannot process runs with different filling scheme if usage of BX numbers is requested");
-
+  
   fFillingScheme      = fFillOADB->GetFillingSchemeName();
-
+  
   AliInfo(Form("Initializing for run %d", runNumber));
   
   // initialize first time?
@@ -967,20 +922,20 @@ Bool_t AliPhysicsSelection::Initialize(Int_t runNumber)
       TIterator * bgIter   = fPSOADB->GetBGTrigClass(ibit)->MakeIterator();
       TObjString * obj = 0;
       while((obj = (TObjString*) collIter->Next())){
-       if (obj->String() != "") {
-         fCollTrigClasses.Add(new TObjString(GetTriggerString(obj)));
-       }
+        if (obj->String() != "") {
+          fCollTrigClasses.Add(new TObjString(GetTriggerString(obj)));
+        }
       }
       // BG classes only make sense for real data
       if(!fMC) {
-       obj = 0 ;
-       while((obj = (TObjString*) bgIter->Next())){
-         if (obj->String() != "") {
-           fBGTrigClasses.Add(new TObjString(GetTriggerString(obj)));
-         }
-       }
+        obj = 0 ;
+        while((obj = (TObjString*) bgIter->Next())){
+          if (obj->String() != "") {
+            fBGTrigClasses.Add(new TObjString(GetTriggerString(obj)));
+          }
+        }
       }
-
+      
     }
     // not sure how to handle this in the case of > x cuts
     // // Book the token histo with the tokens actually used here!
@@ -994,23 +949,23 @@ Bool_t AliPhysicsSelection::Initialize(Int_t runNumber)
     //         Int_t ntokens = fCashedTokens->GetEntries();
     //         Int_t count = fCollTrigClasses->GetEntries() + fBGTrigClasses->GetEntries();
     //         fHistStatisticsTokens = new TH2F("fHistStatisticsTokens", "fHistStatisticsTokens", ntokens + 2, 0.5, ntokens+2+0.5, count, -0.5, -0.5 + count);
-       
+    
     //         Int_t nrow = 0;
     //         fHistStatisticsTokens->GetXaxis()->SetBinLabel(nrow++,  "Trigger class");
     //         for(Int_t itoken = 0; itoken < ntoken; itoken++){
     //           TParameter<Int_t> * param = fCashedTokens->At(itoken);
     //           fHistStatisticsTokens->GetXaxis()->SetBinLabel(nrow++,  param->GetName());      
     //         }
-       
+    
     //         fHistStatisticsTokens->GetXaxis()->SetBinLabel(nrow++,      "Accepted");
-
+    
     // }
-
+    
     
     
     // TODO: 
     // Add a new statistics histo containing only the tokens actually used in the selection
-
+    
     Int_t count = fCollTrigClasses.GetEntries() + fBGTrigClasses.GetEntries();
     
     for (Int_t i=0; i<count; i++)
@@ -1022,30 +977,30 @@ Bool_t AliPhysicsSelection::Initialize(Int_t runNumber)
       triggerAnalysis->SetSPDGFOThreshhold(1);
       triggerAnalysis->SetDoFMD(kFALSE);
       triggerAnalysis->SetCorrZDCCutParams(fTriggerOADB->GetZDCCutRefSumCorr(),
-                                          fTriggerOADB->GetZDCCutRefDeltaCorr(), 
-                                          fTriggerOADB->GetZDCCutSigmaSumCorr(),
-                                          fTriggerOADB->GetZDCCutSigmaDeltaCorr());
+          fTriggerOADB->GetZDCCutRefDeltaCorr(), 
+          fTriggerOADB->GetZDCCutSigmaSumCorr(),
+          fTriggerOADB->GetZDCCutSigmaDeltaCorr());
       triggerAnalysis->SetZNCorrCutParams(fTriggerOADB->GetZDCCutZNATimeCorrMin(),fTriggerOADB->GetZDCCutZNATimeCorrMax(),
-                                         fTriggerOADB->GetZDCCutZNCTimeCorrMin(),fTriggerOADB->GetZDCCutZNCTimeCorrMax());
+          fTriggerOADB->GetZDCCutZNCTimeCorrMin(),fTriggerOADB->GetZDCCutZNCTimeCorrMax());
       fTriggerAnalysis.Add(triggerAnalysis);
     }
-
+    
     
     // TODO: shall I really delete this?
     if (fHistStatistics[0])
       delete fHistStatistics[0];
     if (fHistStatistics[1])
       delete fHistStatistics[1];
-  
+    
     fHistStatistics[kStatIdxBin0] = BookHistStatistics("_Bin0");
     fHistStatistics[kStatIdxAll]  = BookHistStatistics("");
     
-
+    
     if (fHistBunchCrossing)
       delete fHistBunchCrossing;
-  
+    
     fHistBunchCrossing = new TH2F("fHistBunchCrossing", "fHistBunchCrossing;bunch crossing number;", 4000, -0.5, 3999.5,  count, -0.5, -0.5 + count);
-
+    
     // TODO: remove fHistTriggerPattern
     if (fHistTriggerPattern)
       delete fHistTriggerPattern;
@@ -1053,9 +1008,9 @@ Bool_t AliPhysicsSelection::Initialize(Int_t runNumber)
     const int ntrig=3;
     Int_t n = 1;
     const Int_t nbinTrig = TMath::Nint(TMath::Power(2,ntrig));
-
+    
     fHistTriggerPattern = new TH1F("fHistTriggerPattern", "Trigger pattern: FO + 2*v0A + 4*v0C", 
-                                  nbinTrig, -0.5, nbinTrig-0.5);    
+        nbinTrig, -0.5, nbinTrig-0.5);    
     fHistTriggerPattern->GetXaxis()->SetBinLabel(1,"NO TRIG");
     fHistTriggerPattern->GetXaxis()->SetBinLabel(2,"FO");
     fHistTriggerPattern->GetXaxis()->SetBinLabel(3,"v0A");
@@ -1064,8 +1019,8 @@ Bool_t AliPhysicsSelection::Initialize(Int_t runNumber)
     fHistTriggerPattern->GetXaxis()->SetBinLabel(6,"FO & v0C");
     fHistTriggerPattern->GetXaxis()->SetBinLabel(7,"v0A & v0C");
     fHistTriggerPattern->GetXaxis()->SetBinLabel(8,"FO & v0A & v0C");
-
-  
+    
+    
     n = 1;
     for (Int_t i=0; i < fCollTrigClasses.GetEntries(); i++)
     {
@@ -1079,31 +1034,31 @@ Bool_t AliPhysicsSelection::Initialize(Int_t runNumber)
       fHistBunchCrossing->GetYaxis()->SetBinLabel(n, ((TObjString*) fBGTrigClasses.At(i))->String());
       n++;
     }
-
     
-
-  }
     
+    
+  }
+  
   Int_t count = fCollTrigClasses.GetEntries() + fBGTrigClasses.GetEntries();
   for (Int_t i=0; i<count; i++)
   {
     
     AliTriggerAnalysis* triggerAnalysis = static_cast<AliTriggerAnalysis*> (fTriggerAnalysis.At(i));
-  
+    
     switch (runNumber)
     {
-      case 104315:
-      case 104316:
-      case 104320:
-      case 104321:
-      case 104439:
-        triggerAnalysis->SetV0TimeOffset(7.5);
-        break;
-      default:
-        triggerAnalysis->SetV0TimeOffset(0);
+    case 104315:
+    case 104316:
+    case 104320:
+    case 104321:
+    case 104439:
+      triggerAnalysis->SetV0TimeOffset(7.5);
+      break;
+    default:
+      triggerAnalysis->SetV0TimeOffset(0);
     }
   }
-    
+  
   fCurrentRun = runNumber;
   
   TH1::AddDirectory(oldStatus);
@@ -1117,7 +1072,7 @@ TH2F * AliPhysicsSelection::BookHistStatistics(const char * tag) {
   // BG and the ratio of BG and accidentals to total +ratio goot to
   // first col + 2 for error on good.
   // TODO: Remember the the indexes of rows for the BG selection. Add new member fBGRows[] and use kStat as indexes
-
+  
   Int_t count = fCollTrigClasses.GetEntries() + fBGTrigClasses.GetEntries();
 #ifdef VERBOSE_STAT
   Int_t extrarows = fComputeBG != 0 ? 11 : 0;
@@ -1125,7 +1080,7 @@ TH2F * AliPhysicsSelection::BookHistStatistics(const char * tag) {
   Int_t extrarows = fComputeBG != 0 ? 6 : 0;
 #endif
   TH2F * h = new TH2F(Form("fHistStatistics%s",tag), Form("fHistStatistics - %s ;;",tag), kStatAccepted, 0.5, kStatAccepted+0.5, count+extrarows, -0.5, -0.5 + count+extrarows);
-
+  
   h->GetXaxis()->SetBinLabel(kStatTriggerClass,  "Trigger class");
   h->GetXaxis()->SetBinLabel(kStatHWTrig,       "Hardware trigger");
   h->GetXaxis()->SetBinLabel(kStatFO1,          "FO >= 1");
@@ -1156,20 +1111,20 @@ TH2F * AliPhysicsSelection::BookHistStatistics(const char * tag) {
   h->GetXaxis()->SetBinLabel(kStatBG,           "Background identification");
   h->GetXaxis()->SetBinLabel(kStatAcceptedPileUp, "Pile up (in accepted)");
   h->GetXaxis()->SetBinLabel(kStatAccepted,      "Accepted");
-
-
+  
+  
   Int_t n = 1;
   for (Int_t i=0; i < fCollTrigClasses.GetEntries(); i++)
-    {
-      h->GetYaxis()->SetBinLabel(n, ((TObjString*) fCollTrigClasses.At(i))->String());
-      n++;
-    }
+  {
+    h->GetYaxis()->SetBinLabel(n, ((TObjString*) fCollTrigClasses.At(i))->String());
+    n++;
+  }
   for (Int_t i=0; i < fBGTrigClasses.GetEntries(); i++)
-    {
-      h->GetYaxis()->SetBinLabel(n, ((TObjString*) fBGTrigClasses.At(i))->String());
-      n++;
-    }
-
+  {
+    h->GetYaxis()->SetBinLabel(n, ((TObjString*) fBGTrigClasses.At(i))->String());
+    n++;
+  }
+  
   if(fComputeBG) {
     fBGStatOffset = n;
     h->GetYaxis()->SetBinLabel(n++, "All B");
@@ -1186,7 +1141,7 @@ TH2F * AliPhysicsSelection::BookHistStatistics(const char * tag) {
 #endif
     h->GetYaxis()->SetBinLabel(n++, "GOOD");
   }
-
+  
   return h;
 }
 
@@ -1204,7 +1159,7 @@ void AliPhysicsSelection::Print(const Option_t *option) const
   Printf("Background trigger classes:");
   for (Int_t i=0; i < fBGTrigClasses.GetEntries(); i++)
     Printf("%s", ((TObjString*) fBGTrigClasses.At(i))->String().Data());
-
+  
   AliTriggerAnalysis* triggerAnalysis = dynamic_cast<AliTriggerAnalysis*> (fTriggerAnalysis.At(0));
   
   if (triggerAnalysis)
@@ -1222,46 +1177,46 @@ void AliPhysicsSelection::Print(const Option_t *option) const
       TObjString* obj = 0;
       static TString alreadyFoundTriggers;
       while ((obj = dynamic_cast<TObjString*> (iter->Next())))
-       {
-         TString strTrigger = obj->GetString();    
-         TParameter<Long64_t>* param = static_cast<TParameter<Long64_t>*> (triggers->GetValue(obj));
-         Long_t counts =  (Long_t)param->GetVal();
-         TObjArray* tokens = obj->String().Tokenize(" ");
-         for (Int_t i=0; i<tokens->GetEntries(); i++)
-           {
-             TString singleTrigStr = ((TObjString*) tokens->At(i))->String();
-             singleTrigStr.Strip(TString::kBoth, ' ' );
-             const char * singleTrig = singleTrigStr.Data();
-             //            Printf("%s", singleTrig);
-             TString singleTrigStrFull;
-             Bool_t found = kFALSE;
-             Int_t nCollTriggers = fCollTrigClasses.GetEntries();
-             for(Int_t iCollTriggers = 0; iCollTriggers < nCollTriggers; iCollTriggers++){
-               singleTrigStrFull = ((TObjString*)fCollTrigClasses.At(iCollTriggers))->String();
-               if(singleTrigStrFull.Contains(singleTrigStr)) {
-                 found = kTRUE;
-                 break;
-               }
-               singleTrigStrFull = singleTrigStr;
-             }
-             Int_t nBGTriggers = fBGTrigClasses.GetEntries();
-             for(Int_t iBGTriggers = 0; iBGTriggers < nBGTriggers; iBGTriggers++){
-               singleTrigStrFull = ((TObjString*)fBGTrigClasses.At(iBGTriggers))->String();
-               if(singleTrigStrFull.Contains(singleTrigStr)) {
-                 found = kTRUE;
-                 break;
-               }
-               singleTrigStrFull = singleTrigStr;
-             }
-             
-             TString blacklist = "CEMC7WU-B-NOPF-ALL, CEMC7WU-AC-NOPF-ALL CEMC7WU-E-NOPF-ALL C0LSR-ABCE-NOPF-TPC CBEAMB-B-NOPF-ALLNOTRD"; // We know we dont support those, so we print no warning           
-             if(counts>0 && !found && !blacklist.Contains(singleTrig) && !singleTrigStr.Contains("WU") && !alreadyFoundTriggers.Contains(singleTrig)) {
-               Printf("WARNING: Found unknown trigger [%s] with %ld counts in the ESD!", singleTrig, counts);
-               alreadyFoundTriggers += singleTrig; // Avoid printing warning twice for the same trigger
-             }       
-           }    
-         delete tokens;        
-       }
+      {
+        TString strTrigger = obj->GetString();    
+        TParameter<Long64_t>* param = static_cast<TParameter<Long64_t>*> (triggers->GetValue(obj));
+        Long_t counts =  (Long_t)param->GetVal();
+        TObjArray* tokens = obj->String().Tokenize(" ");
+        for (Int_t i=0; i<tokens->GetEntries(); i++)
+        {
+          TString singleTrigStr = ((TObjString*) tokens->At(i))->String();
+          singleTrigStr.Strip(TString::kBoth, ' ' );
+          const char * singleTrig = singleTrigStr.Data();
+          //       Printf("%s", singleTrig);
+          TString singleTrigStrFull;
+          Bool_t found = kFALSE;
+          Int_t nCollTriggers = fCollTrigClasses.GetEntries();
+          for(Int_t iCollTriggers = 0; iCollTriggers < nCollTriggers; iCollTriggers++){
+            singleTrigStrFull = ((TObjString*)fCollTrigClasses.At(iCollTriggers))->String();
+            if(singleTrigStrFull.Contains(singleTrigStr)) {
+              found = kTRUE;
+              break;
+            }
+            singleTrigStrFull = singleTrigStr;
+          }
+          Int_t nBGTriggers = fBGTrigClasses.GetEntries();
+          for(Int_t iBGTriggers = 0; iBGTriggers < nBGTriggers; iBGTriggers++){
+            singleTrigStrFull = ((TObjString*)fBGTrigClasses.At(iBGTriggers))->String();
+            if(singleTrigStrFull.Contains(singleTrigStr)) {
+              found = kTRUE;
+              break;
+            }
+            singleTrigStrFull = singleTrigStr;
+          }
+          
+          TString blacklist = "CEMC7WU-B-NOPF-ALL, CEMC7WU-AC-NOPF-ALL CEMC7WU-E-NOPF-ALL C0LSR-ABCE-NOPF-TPC CBEAMB-B-NOPF-ALLNOTRD"; // We know we dont support those, so we print no warning              
+          if(counts>0 && !found && !blacklist.Contains(singleTrig) && !singleTrigStr.Contains("WU") && !alreadyFoundTriggers.Contains(singleTrig)) {
+            Printf("WARNING: Found unknown trigger [%s] with %ld counts in the ESD!", singleTrig, counts);
+            alreadyFoundTriggers += singleTrig; // Avoid printing warning twice for the same trigger
+          }          
+        }    
+        delete tokens; 
+      }
       delete iter;
     }
   }
@@ -1269,7 +1224,7 @@ void AliPhysicsSelection::Print(const Option_t *option) const
   if (fHistStatistics[kStatIdxAll])
   {
     static TString alreadyFoundTriggers; // avoids printing twice the same warning
-       
+    
     for (Int_t i=0; i<fCollTrigClasses.GetEntries(); i++)
     {
       Printf("\nSelection statistics for collision trigger %s:", ((TObjString*) fCollTrigClasses.At(i))->String().Data());
@@ -1277,7 +1232,7 @@ void AliPhysicsSelection::Print(const Option_t *option) const
       
       Float_t allEvents       = fHistStatistics[kStatIdxAll]->GetBinContent(1, i+1); 
       Float_t triggeredEvents = fHistStatistics[kStatIdxAll]->GetBinContent(fHistStatistics[kStatIdxAll]->GetXaxis()->FindBin("Accepted"), i+1); 
-
+      
       Printf("Total events with correct trigger class: %d", (Int_t) fHistStatistics[kStatIdxAll]->GetBinContent(1, i+1));
       msg += Form("Total events with correct trigger class: %d\n", (Int_t) fHistStatistics[kStatIdxAll]->GetBinContent(1, i+1));
       Printf("Selected collision candidates: %d", (Int_t) fHistStatistics[kStatIdxAll]->GetBinContent(fHistStatistics[kStatIdxAll]->GetXaxis()->FindBin("Accepted"), i+1));
@@ -1286,12 +1241,12 @@ void AliPhysicsSelection::Print(const Option_t *option) const
       // If the fraction of accepted events is too low, print a warning.
       Float_t eff = allEvents > 0 ? triggeredEvents/allEvents : 0;
       if(allEvents > 0 && (eff < 0.5) &&  // FIXME: make threshold programmable in OADB
-        !alreadyFoundTriggers.Contains(((TObjString*) fCollTrigClasses.At(i))->String().Data())) {
-       Printf("WARNING: Trigger class %s has a very low efficiency (%d/%d=%.2f)",((TObjString*) fCollTrigClasses.At(i))->String().Data(), (Int_t) triggeredEvents, (Int_t) allEvents, eff);
-       alreadyFoundTriggers += ((TObjString*) fCollTrigClasses.At(i))->String().Data();
-       Printf("%s", alreadyFoundTriggers.Data());
+          !alreadyFoundTriggers.Contains(((TObjString*) fCollTrigClasses.At(i))->String().Data())) {
+        Printf("WARNING: Trigger class %s has a very low efficiency (%d/%d=%.2f)",((TObjString*) fCollTrigClasses.At(i))->String().Data(), (Int_t) triggeredEvents, (Int_t) allEvents, eff);
+        alreadyFoundTriggers += ((TObjString*) fCollTrigClasses.At(i))->String().Data();
+        Printf("%s", alreadyFoundTriggers.Data());
       }
-
+      
     }
   }
   
@@ -1308,7 +1263,7 @@ void AliPhysicsSelection::Print(const Option_t *option) const
       for (Int_t j=1; j<=fHistBunchCrossing->GetNbinsX(); j++)
         if (fHistBunchCrossing->GetBinContent(j, i) > 0)
           str += Form("%d, ", (Int_t) fHistBunchCrossing->GetXaxis()->GetBinCenter(j));
-             
+      
       Printf("%s", str.Data());
       msg += str;
       msg += "\n";
@@ -1332,7 +1287,7 @@ void AliPhysicsSelection::Print(const Option_t *option) const
         Printf("WARNING: Bunch crossing %d has collision and BG trigger classes active. Check BPTX functioning for this run!", (Int_t) fHistBunchCrossing->GetXaxis()->GetBinCenter(j));
     }
   }
-
+  
   if (fUsingCustomClasses)        
     Printf("WARNING: Using custom trigger classes!");
   if (fSkipTriggerClassSelection) 
@@ -1344,8 +1299,8 @@ void AliPhysicsSelection::Print(const Option_t *option) const
   TString opt(option);
   opt.ToUpper();
   if (opt == "STAT") {
-     AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
-     if (mgr) mgr->AddStatisticsMsg(msg);
+    AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+    if (mgr) mgr->AddStatisticsMsg(msg);
   }
 }
 
@@ -1354,23 +1309,23 @@ Long64_t AliPhysicsSelection::Merge(TCollection* list)
   // Merge a list of AliMultiplicityCorrection objects with this (needed for
   // PROOF).
   // Returns the number of merged objects (including this).
-
+  
   if (!list)
     return 0;
-
+  
   if (list->IsEmpty())
     return 1;
-
+  
   TIterator* iter = list->MakeIterator();
   TObject* obj;
   
   // collections of all histograms
   const Int_t nHists = 8;
   TList collections[nHists];
-
+  
   Int_t count = 0;
   while ((obj = iter->Next())) {
-
+    
     AliPhysicsSelection* entry = dynamic_cast<AliPhysicsSelection*> (obj);
     if (entry == 0) 
       continue;
@@ -1391,22 +1346,22 @@ Long64_t AliPhysicsSelection::Merge(TCollection* list)
         fBGTrigClasses.Add(entry->fBGTrigClasses.At(i)->Clone());
     }
     if (fCurrentRun != currentRun)
-       AliWarning(Form("Current run %d not matching the one to be merged with %d", fCurrentRun, currentRun));
-
+      AliWarning(Form("Current run %d not matching the one to be merged with %d", fCurrentRun, currentRun));
+    
     // With the same strategy update fBGStatOffset
     Int_t bgstatoffset = entry->GetBGStatOffset();
     
     // Nothing to merge with since BG was not initialized.
     if (!(bgstatoffset < 0)){
       if (fBGStatOffset < 0) 
-       {
-         fBGStatOffset = bgstatoffset;
-       }
+      {
+        fBGStatOffset = bgstatoffset;
+      }
     }
     if (fBGStatOffset != bgstatoffset)
       AliWarning(Form("Current run %d not matching the one to be merged with %d", fBGStatOffset, bgstatoffset));
     
-
+    
     
     // Merge the OADBs (Take just the first instance you find
     if (!fPSOADB && entry->GetOADBPhysicsSelection()) {
@@ -1415,7 +1370,7 @@ Long64_t AliPhysicsSelection::Merge(TCollection* list)
     if (!fFillOADB && entry->GetOADBFillingScheme()){
       fFillOADB = (AliOADBFillingScheme*) entry->GetOADBFillingScheme()->Clone();
     }
-
+    
     if (entry->fTriggerAnalysis.GetEntries() > 0)
       collections[0].Add(&(entry->fTriggerAnalysis));
     if (entry->fHistStatistics[0])
@@ -1428,10 +1383,10 @@ Long64_t AliPhysicsSelection::Merge(TCollection* list)
       collections[3].Add(entry->fHistBunchCrossing);
     if (entry->fHistTriggerPattern)
       collections[4].Add(entry->fHistTriggerPattern);
-
+    
     count++;
   }
-
+  
   if (fTriggerAnalysis.GetEntries() == 0 && collections[0].GetEntries() > 0)
   {
     TList* firstList = (TList*) collections[0].First();
@@ -1450,7 +1405,7 @@ Long64_t AliPhysicsSelection::Merge(TCollection* list)
   }
   if (fHistStatistics[0])
     fHistStatistics[0]->Merge(&collections[1]);
-    
+  
   if (!fHistStatistics[1] && collections[2].GetEntries() > 0)
   {
     fHistStatistics[1] = (TH2F*) collections[2].First()->Clone();
@@ -1458,7 +1413,7 @@ Long64_t AliPhysicsSelection::Merge(TCollection* list)
   }
   if (fHistStatistics[1])
     fHistStatistics[1]->Merge(&collections[2]);
-    
+  
   if (!fHistBunchCrossing && collections[3].GetEntries() > 0)
   {
     fHistBunchCrossing = (TH2F*) collections[3].First()->Clone();
@@ -1474,9 +1429,9 @@ Long64_t AliPhysicsSelection::Merge(TCollection* list)
   }
   if (fHistTriggerPattern)
     fHistTriggerPattern->Merge(&collections[4]);
-    
+  
   delete iter;
-
+  
   return count+1;
 }
 
@@ -1486,18 +1441,18 @@ void AliPhysicsSelection::SaveHistograms(const char* folder)
   
   if (!fHistStatistics[0] || !fHistStatistics[1])
     return;
-    
+  
   if (folder)
   {
     gDirectory->mkdir(folder);
     gDirectory->cd(folder);
   }
   
-
+  
   // Fill the last rows of fHistStatistics before saving
   if (fComputeBG) {      
     AliInfo("BG estimate assumes that for a given run you only have A and C triggers separately or"
-           " toghether as a AC class! Make sure this assumption holds in your case"); 
+        " toghether as a AC class! Make sure this assumption holds in your case"); 
     
     // use an anum for the different trigger classes, to make loops easier to read
     enum {kClassB =0 , kClassA, kClassC, kClassAC, kClassE, kNClasses};
@@ -1514,24 +1469,24 @@ void AliPhysicsSelection::SaveHistograms(const char* folder)
     // Those are used to rescale the different classes to the same number of bx ids
     // TODO: pass names of the rows for B, CA and E and look names of the rows. How do I handle the case in which both AC are in the same row?         
     Int_t nBXIds[kNClasses] = {0};
-      //      cout <<"Computing BG:" << endl;
+    //      cout <<"Computing BG:" << endl;
     
     for(Int_t iTrigClass = 0; iTrigClass < kNClasses; iTrigClass++){
       for(Int_t irow = 0; irow < nrows[iTrigClass]; irow++) {
-       if(irow==0) cout << "- Class " << classFlags[iTrigClass] << endl;   
-       for (Int_t j=1; j<=fHistBunchCrossing->GetNbinsX(); j++) {
-         if (fHistBunchCrossing->GetBinContent(j, rows[iTrigClass][irow]) > 0) {
-           nBXIds[iTrigClass]++;        
-         }
-       }
-       if(nBXIds[iTrigClass]>0) cout << "   Using row " << rows[iTrigClass][irow] <<  ": " 
-                                     << fHistBunchCrossing->GetYaxis()->GetBinLabel(rows[iTrigClass][irow]) 
-                                     << " (nBXID "<< nBXIds[iTrigClass] << ")"<< endl;
-
+        if(irow==0) cout << "- Class " << classFlags[iTrigClass] << endl;   
+        for (Int_t j=1; j<=fHistBunchCrossing->GetNbinsX(); j++) {
+          if (fHistBunchCrossing->GetBinContent(j, rows[iTrigClass][irow]) > 0) {
+            nBXIds[iTrigClass]++;       
+          }
+        }
+        if(nBXIds[iTrigClass]>0) cout << "   Using row " << rows[iTrigClass][irow] <<  ": " 
+            << fHistBunchCrossing->GetYaxis()->GetBinLabel(rows[iTrigClass][irow]) 
+            << " (nBXID "<< nBXIds[iTrigClass] << ")"<< endl;
+        
       }
-
+      
     }
-
+    
     Float_t ratioToB[kNClasses];
     ratioToB[kClassE]  = nBXIds[kClassE]  >0 ? Float_t(nBXIds[kClassB])/nBXIds[kClassE]   : 0;
     ratioToB[kClassA]  = nBXIds[kClassA]  >0 ? Float_t(nBXIds[kClassB])/nBXIds[kClassA]   : 0;
@@ -1543,127 +1498,127 @@ void AliPhysicsSelection::SaveHistograms(const char* folder)
     Printf("  B/C  = %d/%d = %f", nBXIds[kClassB],nBXIds[kClassC], ratioToB[kClassC] );
     Printf("  B/AC = %d/%d = %f", nBXIds[kClassB],nBXIds[kClassAC],ratioToB[kClassAC]);
     Int_t nHistStat = 2;
-
+    
     // 1. loop over all cols
     for(Int_t iHistStat = 0; iHistStat < nHistStat; iHistStat++){
       Int_t ncol = fHistStatistics[iHistStat]->GetNbinsX();
       Float_t good1 = 0;      
       for(Int_t icol = 1; icol <= ncol; icol++) {
-       Int_t nEvents[kNClasses] = {0}; // number of events should be reset at every column
-       // For all trigger classes, add up over row matching trigger mask (as selected before)
-       for(Int_t iTrigClass = 0; iTrigClass < kNClasses; iTrigClass++){
-         for(Int_t irow = 0; irow < nrows[iTrigClass]; irow++) {         
-           nEvents[iTrigClass] += (Int_t) fHistStatistics[iHistStat]->GetBinContent(icol,rows[iTrigClass][irow]);      
-         }
-         //        cout << "Events " << classFlags[iTrigClass] << " ("<<icol<<") " << nEvents[iTrigClass] << endl;         
-       }
-       if (nEvents[kClassB]>0) {
-         Float_t acc  = ratioToB[kClassE]*nEvents[kClassE]; 
-         Double_t accErr = TMath::Sqrt(ratioToB[kClassE]*ratioToB[kClassE]*nEvents[kClassE]);
-         //      Int_t bg   = cint1A + cint1C - 2*acc;
-           
-         // If intensity measurements are available, they already
-         // contain the scaling for BX ratios, so we reset the
-         // ratioToB entries
-         if(icol == 1) {
-           if(fBIFactorAC > 0 || fBIFactorA > 0 || fBIFactorC > 0) {
-             if (fBIFactorAC <= 0 && (fBIFactorA <= 0 || fBIFactorC <= 0)) {
-               AliError("Not all intensities set!, assuming equal intensities");
-               fBIFactorA  = 1;
-               fBIFactorC  = 1;
-               fBIFactorAC = 1;
-             } else {
-               AliInfo("Using ratio of number of bunch crossing embedded in the intensity measurements");
-               ratioToB[kClassA]  = ratioToB[kClassA]  >0 ? 1  : 0;
-               ratioToB[kClassC]  = ratioToB[kClassC]  >0 ? 1  : 0;
-               ratioToB[kClassAC] = ratioToB[kClassAC] >0 ? 1  : 0;
-               AliInfo(Form(" - BI Factor A:  %f",  fBIFactorA ));
-               AliInfo(Form(" - BI Factor C:  %f",  fBIFactorC ));
-               AliInfo(Form(" - BI Factor AC: %f",  fBIFactorAC ));
-               
-             }
-           } else {
-             AliWarning("Intensities not set!, assuming equal intensities");
-             fBIFactorA  = 1;
-             fBIFactorC  = 1;
-             fBIFactorAC = 1;
-           }
-         }
-         // Assuming that for a given class the triggers are either recorded as A+C or AC
-         Float_t bg  = nEvents[kClassAC] > 0 ?
-           fBIFactorAC*(ratioToB[kClassAC]*nEvents[kClassAC] - 2*acc):
-           fBIFactorA* (ratioToB[kClassA]*nEvents[kClassA]-acc) + 
-           fBIFactorC* (ratioToB[kClassC]*nEvents[kClassC]-acc) ;
-
-         // cout << "-----------------------" << endl;
-         // cout << "Factors: " << fBIFactorA << " " << fBIFactorC << " " << fBIFactorAC << endl;
-         // cout << "Ratios: "  << ratioToB[kClassA] << " " << ratioToB[kClassC] << " " << ratioToB[kClassAC] << endl;
-         // cout << "Evts:   "  << nEvents[kClassA] << " " << nEvents[kClassC] << " " << nEvents[kClassAC] << " " <<  nEvents[kClassB] << endl;
-         // cout << "Acc: " << acc << endl;
-         // cout << "BG: " << bg << endl;
-         // cout  << "  " <<   fBIFactorA* (ratioToB[kClassA]*nEvents[kClassA]-acc) <<endl;
-         // cout  << "  " <<   fBIFactorC* (ratioToB[kClassC]*nEvents[kClassC]-acc) <<endl;
-         // cout  << "  " <<   fBIFactorAC*(ratioToB[kClassAC]*nEvents[kClassAC] - 2*acc) << endl;
-         // cout << "-----------------------" << endl;
-
-         Float_t good = Float_t(nEvents[kClassB]) - bg - acc;
-         if (icol ==1) good1 = good;
-         //      Float_t errGood     = TMath::Sqrt(2*(nEvents[kClassA]+nEvents[kClassC]+nEvents[kClassE]));// Error on the number of goods assuming only bg fluctuates
-         //      DeltaG^2 = B + FA^2 A + FC^2 C + Ratio^2 (FA+FC-1)^2 E.
-         Float_t errGood     = nEvents[kClassAC] > 0 ? 
-           TMath::Sqrt( nEvents[kClassB] +
-                        fBIFactorAC*fBIFactorAC*ratioToB[kClassAC]*ratioToB[kClassAC]*nEvents[kClassAC] +
-                        ratioToB[kClassE] * ratioToB[kClassE] * 
-                        (fBIFactorAC - 1)*(fBIFactorAC - 1)*nEvents[kClassE]) :  
-           TMath::Sqrt( nEvents[kClassB] + 
-                        fBIFactorA*fBIFactorA*ratioToB[kClassA]*ratioToB[kClassA]*nEvents[kClassA] +
-                        fBIFactorC*fBIFactorC*ratioToB[kClassC]*ratioToB[kClassC]*nEvents[kClassC] +
-                        ratioToB[kClassE] * ratioToB[kClassE] * 
-                        (fBIFactorA + fBIFactorC - 1)*(fBIFactorA + fBIFactorC - 1)*nEvents[kClassE]);
-
-         Float_t errBG = nEvents[kClassAC] > 0 ? 
-           TMath::Sqrt(fBIFactorAC*fBIFactorAC*ratioToB[kClassAC]*ratioToB[kClassAC]*nEvents[kClassAC]+
-                       4*ratioToB[kClassE]*ratioToB[kClassE]*(fBIFactorAC*fBIFactorAC)*nEvents[kClassE]) :
-           TMath::Sqrt(fBIFactorA*fBIFactorA*ratioToB[kClassA]*ratioToB[kClassA]*nEvents[kClassA]+
-                       fBIFactorC*fBIFactorC*ratioToB[kClassC]*ratioToB[kClassC]*nEvents[kClassC]+
-                       ratioToB[kClassE]*ratioToB[kClassE]*(fBIFactorA+fBIFactorC)*(fBIFactorA+fBIFactorC)*nEvents[kClassE]);
-       
-       
-         fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowAllB, nEvents[kClassB]); 
-         fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowAllAC,nEvents[kClassA]+nEvents[kClassC]+nEvents[kClassAC]);      
-         fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowAllE, nEvents[kClassE]); 
-
-         fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowBG,bg);  
-         fHistStatistics[iHistStat]->SetBinError  (icol,fBGStatOffset+kStatRowBG,errBG);       
-         fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowAcc,acc);        
-         fHistStatistics[iHistStat]->SetBinError  (icol,fBGStatOffset+kStatRowAcc,accErr);     
-         fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowGood,good);    
-         fHistStatistics[iHistStat]->SetBinError  (icol,fBGStatOffset+kStatRowGood,errGood);    
-
+        Int_t nEvents[kNClasses] = {0}; // number of events should be reset at every column
+        // For all trigger classes, add up over row matching trigger mask (as selected before)
+        for(Int_t iTrigClass = 0; iTrigClass < kNClasses; iTrigClass++){
+          for(Int_t irow = 0; irow < nrows[iTrigClass]; irow++) {        
+            nEvents[iTrigClass] += (Int_t) fHistStatistics[iHistStat]->GetBinContent(icol,rows[iTrigClass][irow]);     
+          }
+          //       cout << "Events " << classFlags[iTrigClass] << " ("<<icol<<") " << nEvents[iTrigClass] << endl;         
+        }
+        if (nEvents[kClassB]>0) {
+          Float_t acc  = ratioToB[kClassE]*nEvents[kClassE]; 
+          Double_t accErr = TMath::Sqrt(ratioToB[kClassE]*ratioToB[kClassE]*nEvents[kClassE]);
+          //      Int_t bg   = cint1A + cint1C - 2*acc;
+          
+          // If intensity measurements are available, they already
+          // contain the scaling for BX ratios, so we reset the
+          // ratioToB entries
+          if(icol == 1) {
+            if(fBIFactorAC > 0 || fBIFactorA > 0 || fBIFactorC > 0) {
+              if (fBIFactorAC <= 0 && (fBIFactorA <= 0 || fBIFactorC <= 0)) {
+                AliError("Not all intensities set!, assuming equal intensities");
+                fBIFactorA  = 1;
+                fBIFactorC  = 1;
+                fBIFactorAC = 1;
+              } else {
+                AliInfo("Using ratio of number of bunch crossing embedded in the intensity measurements");
+                ratioToB[kClassA]  = ratioToB[kClassA]  >0 ? 1  : 0;
+                ratioToB[kClassC]  = ratioToB[kClassC]  >0 ? 1  : 0;
+                ratioToB[kClassAC] = ratioToB[kClassAC] >0 ? 1  : 0;
+                AliInfo(Form(" - BI Factor A:  %f",  fBIFactorA ));
+                AliInfo(Form(" - BI Factor C:  %f",  fBIFactorC ));
+                AliInfo(Form(" - BI Factor AC: %f",  fBIFactorAC ));
+                
+              }
+            } else {
+              AliWarning("Intensities not set!, assuming equal intensities");
+              fBIFactorA  = 1;
+              fBIFactorC  = 1;
+              fBIFactorAC = 1;
+            }
+          }
+          // Assuming that for a given class the triggers are either recorded as A+C or AC
+          Float_t bg  = nEvents[kClassAC] > 0 ?
+              fBIFactorAC*(ratioToB[kClassAC]*nEvents[kClassAC] - 2*acc):
+              fBIFactorA* (ratioToB[kClassA]*nEvents[kClassA]-acc) + 
+              fBIFactorC* (ratioToB[kClassC]*nEvents[kClassC]-acc) ;
+          
+          // cout << "-----------------------" << endl;
+          // cout << "Factors: " << fBIFactorA << " " << fBIFactorC << " " << fBIFactorAC << endl;
+          // cout << "Ratios: "  << ratioToB[kClassA] << " " << ratioToB[kClassC] << " " << ratioToB[kClassAC] << endl;
+          // cout << "Evts:   "  << nEvents[kClassA] << " " << nEvents[kClassC] << " " << nEvents[kClassAC] << " " <<  nEvents[kClassB] << endl;
+          // cout << "Acc: " << acc << endl;
+          // cout << "BG: " << bg << endl;
+          // cout  << "  " <<   fBIFactorA* (ratioToB[kClassA]*nEvents[kClassA]-acc) <<endl;
+          // cout  << "  " <<   fBIFactorC* (ratioToB[kClassC]*nEvents[kClassC]-acc) <<endl;
+          // cout  << "  " <<   fBIFactorAC*(ratioToB[kClassAC]*nEvents[kClassAC] - 2*acc) << endl;
+          // cout << "-----------------------" << endl;
+          
+          Float_t good = Float_t(nEvents[kClassB]) - bg - acc;
+          if (icol ==1) good1 = good;
+          //      Float_t errGood     = TMath::Sqrt(2*(nEvents[kClassA]+nEvents[kClassC]+nEvents[kClassE]));// Error on the number of goods assuming only bg fluctuates
+          //      DeltaG^2 = B + FA^2 A + FC^2 C + Ratio^2 (FA+FC-1)^2 E.
+          Float_t errGood     = nEvents[kClassAC] > 0 ? 
+              TMath::Sqrt( nEvents[kClassB] +
+                  fBIFactorAC*fBIFactorAC*ratioToB[kClassAC]*ratioToB[kClassAC]*nEvents[kClassAC] +
+                  ratioToB[kClassE] * ratioToB[kClassE] * 
+                  (fBIFactorAC - 1)*(fBIFactorAC - 1)*nEvents[kClassE]) :  
+                  TMath::Sqrt( nEvents[kClassB] + 
+                      fBIFactorA*fBIFactorA*ratioToB[kClassA]*ratioToB[kClassA]*nEvents[kClassA] +
+                      fBIFactorC*fBIFactorC*ratioToB[kClassC]*ratioToB[kClassC]*nEvents[kClassC] +
+                      ratioToB[kClassE] * ratioToB[kClassE] * 
+                      (fBIFactorA + fBIFactorC - 1)*(fBIFactorA + fBIFactorC - 1)*nEvents[kClassE]);
+          
+          Float_t errBG = nEvents[kClassAC] > 0 ? 
+              TMath::Sqrt(fBIFactorAC*fBIFactorAC*ratioToB[kClassAC]*ratioToB[kClassAC]*nEvents[kClassAC]+
+                  4*ratioToB[kClassE]*ratioToB[kClassE]*(fBIFactorAC*fBIFactorAC)*nEvents[kClassE]) :
+                  TMath::Sqrt(fBIFactorA*fBIFactorA*ratioToB[kClassA]*ratioToB[kClassA]*nEvents[kClassA]+
+                      fBIFactorC*fBIFactorC*ratioToB[kClassC]*ratioToB[kClassC]*nEvents[kClassC]+
+                      ratioToB[kClassE]*ratioToB[kClassE]*(fBIFactorA+fBIFactorC)*(fBIFactorA+fBIFactorC)*nEvents[kClassE]);
+          
+          
+          fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowAllB, nEvents[kClassB]);        
+          fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowAllAC,nEvents[kClassA]+nEvents[kClassC]+nEvents[kClassAC]);     
+          fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowAllE, nEvents[kClassE]);        
+          
+          fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowBG,bg); 
+          fHistStatistics[iHistStat]->SetBinError  (icol,fBGStatOffset+kStatRowBG,errBG);      
+          fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowAcc,acc);       
+          fHistStatistics[iHistStat]->SetBinError  (icol,fBGStatOffset+kStatRowAcc,accErr);    
+          fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowGood,good);    
+          fHistStatistics[iHistStat]->SetBinError  (icol,fBGStatOffset+kStatRowGood,errGood);    
+          
 #ifdef VERBOSE_STAT
-         //kStatRowBG=0,kStatRowAcc,kStatRowBGFrac,kStatRowAccFrac,kStatRowErrGoodFrac,kStatRowGoodFrac,kStatRowGood,kStatRowErrGood
-         Float_t accFrac   = Float_t(acc) / nEvents[kClassB]  *100;
-         Float_t errAccFrac= Float_t(accErr) / nEvents[kClassB]  *100;
-         Float_t bgFrac    = Float_t(bg)  / nEvents[kClassB]  *100;
-         Float_t goodFrac  = Float_t(good)  / good1 *100;
-         Float_t errGoodFrac = errGood/good1 * 100;
-         Float_t errFracBG = bg > 0 ? TMath::Sqrt((errBG/bg)*(errBG/bg) + 1/nEvents[kClassB])*bgFrac : 0;
-         fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowBGFrac,bgFrac);  
-         fHistStatistics[iHistStat]->SetBinError  (icol,fBGStatOffset+kStatRowBGFrac,errFracBG);       
-         fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowAccFrac,accFrac);    
-         fHistStatistics[iHistStat]->SetBinError  (icol,fBGStatOffset+kStatRowAccFrac,errAccFrac);    
-         fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowGoodFrac,goodFrac);    
-         fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowErrGoodFrac,errGoodFrac);    
-         fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowErrGood,errGood);    
+          //kStatRowBG=0,kStatRowAcc,kStatRowBGFrac,kStatRowAccFrac,kStatRowErrGoodFrac,kStatRowGoodFrac,kStatRowGood,kStatRowErrGood
+          Float_t accFrac   = Float_t(acc) / nEvents[kClassB]  *100;
+          Float_t errAccFrac= Float_t(accErr) / nEvents[kClassB]  *100;
+          Float_t bgFrac    = Float_t(bg)  / nEvents[kClassB]  *100;
+          Float_t goodFrac  = Float_t(good)  / good1 *100;
+          Float_t errGoodFrac = errGood/good1 * 100;
+          Float_t errFracBG = bg > 0 ? TMath::Sqrt((errBG/bg)*(errBG/bg) + 1/nEvents[kClassB])*bgFrac : 0;
+          fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowBGFrac,bgFrac); 
+          fHistStatistics[iHistStat]->SetBinError  (icol,fBGStatOffset+kStatRowBGFrac,errFracBG);      
+          fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowAccFrac,accFrac);    
+          fHistStatistics[iHistStat]->SetBinError  (icol,fBGStatOffset+kStatRowAccFrac,errAccFrac);    
+          fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowGoodFrac,goodFrac);    
+          fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowErrGoodFrac,errGoodFrac);    
+          fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowErrGood,errGood);    
 #endif
-       }
+        }
       }
     }
     for (Int_t iTrigClass = 0; iTrigClass < kNClasses; iTrigClass++){
       delete [] rows[iTrigClass];
     }  
   } // end of ComputeBackground  
-
+  
   fHistStatistics[0]->Write();
   fHistStatistics[1]->Write();
   if(fHistBunchCrossing ) fHistBunchCrossing ->Write();
@@ -1671,21 +1626,21 @@ void AliPhysicsSelection::SaveHistograms(const char* folder)
   
   Int_t count = fCollTrigClasses.GetEntries() + fBGTrigClasses.GetEntries();
   for (Int_t i=0; i < count; i++)
-    {
-      TString triggerClass = "trigger_histograms_";
-      if (i < fCollTrigClasses.GetEntries())
-       triggerClass += ((TObjString*) fCollTrigClasses.At(i))->String();
-      else
-       triggerClass += ((TObjString*) fBGTrigClasses.At(i - fCollTrigClasses.GetEntries()))->String();
-      
-      gDirectory->mkdir(triggerClass);
-      gDirectory->cd(triggerClass);
-      
-      static_cast<AliTriggerAnalysis*> (fTriggerAnalysis.At(i))->SaveHistograms();
-      
-      gDirectory->cd("..");
-    }
+  {
+    TString triggerClass = "trigger_histograms_";
+    if (i < fCollTrigClasses.GetEntries())
+      triggerClass += ((TObjString*) fCollTrigClasses.At(i))->String();
+    else
+      triggerClass += ((TObjString*) fBGTrigClasses.At(i - fCollTrigClasses.GetEntries()))->String();
     
+    gDirectory->mkdir(triggerClass);
+    gDirectory->cd(triggerClass);
+    
+    static_cast<AliTriggerAnalysis*> (fTriggerAnalysis.At(i))->SaveHistograms();
+    
+    gDirectory->cd("..");
+  }
+  
   if (folder)
     gDirectory->cd("..");
   
@@ -1698,18 +1653,18 @@ Int_t AliPhysicsSelection::GetStatRow(const char * triggerBXClass, UInt_t offlin
   // triggerBXClass can be either "A", "AC", "B" or "E"
   // offlineTriggerType is one of the types defined in AliVEvent
   // User should delete rowIDs if no longer needed
-
+  
   if(!fHistStatistics[0]) {
     AliWarning("Not initialized, returning 0");
     return 0;
   }
   const Int_t nrows = fHistStatistics[0]->GetNbinsY();
-
+  
   // allocate memory for at maximum nrows
   Int_t nMatches = 0;
   (*rowIDs) = new UInt_t[nrows];
-
-
+  
+  
   // Loop over rows and find matching ones, using the PS OADB
   // FIXME: check BG estimates
   for(Int_t irow = 1; irow <= nrows; irow++){
@@ -1720,13 +1675,13 @@ Int_t AliPhysicsSelection::GetStatRow(const char * triggerBXClass, UInt_t offlin
       UInt_t tType = ((TObjString*)arr->At(1))->GetString().Atoi();
       
       if (tType == offlineTriggerType && fPSOADB->GetBeamSide(triggerClassCurrent.Data()) == triggerBXClass) {
-       (*rowIDs)[nMatches] = irow;
-       nMatches++;
+        (*rowIDs)[nMatches] = irow;
+        nMatches++;
       }
-
+      
     }
     delete arr;
-
+    
   }
   
   return nMatches;
@@ -1745,12 +1700,12 @@ void AliPhysicsSelection::SetBIFactors(const AliESDEvent * aESD) {
     Double_t intCB = esdRun->GetMeanIntensityIntecting(1);
     Double_t intAA = esdRun->GetMeanIntensityNonIntecting(0);
     Double_t intCC = esdRun->GetMeanIntensityNonIntecting(1);
-
+    
     // cout << "INT " <<intAB <<endl;
     // cout << "INT " <<intCB <<endl;
     // cout << "INT " <<intAA <<endl;
     // cout << "INT " <<intCC <<endl;
-
+    
     if (intAB > 0 && intAA > 0) {
       fBIFactorA = intAB/intAA;
     } else {
@@ -1762,14 +1717,14 @@ void AliPhysicsSelection::SetBIFactors(const AliESDEvent * aESD) {
     } else {
       AliWarning("Cannot set fBIFactorC");
     }
-      
+    
     if (intAB > 0 && intAA > 0 &&
-       intCB > 0 && intCC > 0) {
+        intCB > 0 && intCC > 0) {
       fBIFactorAC = (intAB+intCB)/(intAA+intCC);
     } else {
       AliWarning("Cannot set fBIFactorAC");
     }
-        
+    
   }  
   else {
     // First runs. Intensities hardcoded
@@ -1891,7 +1846,7 @@ void AliPhysicsSelection::SetBIFactors(const AliESDEvent * aESD) {
       fBIFactorC = 1;
     }
   }
-
+  
 }
 
 const char * AliPhysicsSelection::GetTriggerString(TObjString * obj) { 
@@ -1899,17 +1854,17 @@ const char * AliPhysicsSelection::GetTriggerString(TObjString * obj) {
   static TString retString;
   
   retString.Form("%s%s", 
-                obj->String().Data(), 
-                fUseBXNumbers ? fFillOADB->GetBXIDs(fPSOADB->GetBeamSide(obj->String().Data())) : ""  
-                );
-
+      obj->String().Data(), 
+      fUseBXNumbers ? fFillOADB->GetBXIDs(fPSOADB->GetBeamSide(obj->String().Data())) : ""  
+  );
+  
   if (fMC) {
     TPRegexp stripClasses("\\+\\S* ");
     stripClasses.Substitute(retString,"","g");
     stripClasses=TPRegexp("\\-\\S* ");
     stripClasses.Substitute(retString,"","g");
   }
-
+  
   return retString.Data();
 }
 
@@ -1920,7 +1875,7 @@ void AliPhysicsSelection::AddCollisionTriggerClass(const char* className){
     fPSOADB->SetHardwareTrigger         ( 0,"SPDGFO >= 1 || V0A || V0C");
     fPSOADB->SetOfflineTrigger          ( 0,"(SPDGFO >= 1 || V0A || V0C) && !V0ABG && !V0CBG");
   }
-
+  
   // Strip all which is not needed, if BX ids are provided, they are still used here
   // offline trigger and logics are appended automagically, so we strip-em out if they are provided
   TString classNameStripped = className;
@@ -1928,24 +1883,24 @@ void AliPhysicsSelection::AddCollisionTriggerClass(const char* className){
     classNameStripped.Remove(classNameStripped.Index("*")); // keep only the class name (no bx, offline trigger...)   
   if(classNameStripped.Index("&")>0)
     classNameStripped.Remove(classNameStripped.Index("&")); // keep only the class name (no bx, offline trigger...)   
-
+  
   fPSOADB->AddCollisionTriggerClass   ( AliVEvent::kUserDefined,classNameStripped.Data(),"B",0);
   
   fUsingCustomClasses = kTRUE;
-
-
+  
+  
 }
 
 void AliPhysicsSelection::AddBGTriggerClass(const char* className){
   // Add custom BG trigger class
+  
   AliError("This method is deprecated! Will be removed soon! Please use SetCustomOADBObjects() instead!");
   if(!fPSOADB) {
     fPSOADB = new AliOADBPhysicsSelection("CustomPS");   
     fPSOADB->SetHardwareTrigger         ( 0,"SPDGFO >= 1 || V0A || V0C");
     fPSOADB->SetOfflineTrigger          ( 0,"(SPDGFO >= 1 || V0A || V0C) && !V0ABG && !V0CBG");
   }
-
+  
   // Strip all which is not needed, if BX ids are provided, they are still used here
   // offline trigger and logics are appended automagically, so we strip-em out if they are provided
   TString classNameStripped = className;
@@ -1953,11 +1908,11 @@ void AliPhysicsSelection::AddBGTriggerClass(const char* className){
     classNameStripped.Remove(classNameStripped.Index("*")); // keep only the class name (no bx, offline trigger...)   
   if(classNameStripped.Index("&")>0)
     classNameStripped.Remove(classNameStripped.Index("&")); // keep only the class name (no bx, offline trigger...)   
-
+  
   fPSOADB->AddBGTriggerClass   ( AliVEvent::kUserDefined,classNameStripped.Data(),"AC",0);
-
+  
   fUsingCustomClasses = kTRUE;
-
+  
 }       
 
 
@@ -1981,9 +1936,9 @@ void AliPhysicsSelection::DetectPassName(){
     }
     delete tokens;
   } 
-
+  
   TString passName="";
-
+  
   TObjArray* tokens = filePath.Tokenize("/");
   for (Int_t i=0;i<=tokens->GetLast();i++) {
     TObjString* stObj = (TObjString*) tokens->At(i);
@@ -2003,20 +1958,20 @@ void AliPhysicsSelection::DetectPassName(){
       TObjString* stObj = (TObjString*) tokens2->At(i);
       TString s = stObj->GetString();
       if (s.Contains("pass")) {
-       passName = s;
-       break;
+        passName = s;
+        break;
       }
     }
     delete tokens2;
   }
-
-
+  
+  
   if (!passName.Contains("pass")){
     AliError(" Failed to find reconstruction pass name:");
     AliError(" --> If these are MC data: please set kTRUE first argument of AddTaskPhysicsSelection");
     AliFatal(" --> If these are real data: please insert pass name inside the path of your local file, e.g. /your_path/pass2/AliESDs.root");
   }
-
+  
   AliInfo(Form("pass name: %s\n",passName.Data()));
   fPassName = passName;
 }
index a6fd140a3e619d23bd91683fcc3b9cad1492c794..280c3924f2e753558a01c83eff550fc002c4cdb2 100644 (file)
 //   Origin: Jan Fiete Grosse-Oetringhaus, CERN
 //-------------------------------------------------------------------------
 
-#include <Riostream.h>
-#include <TH1F.h>
-#include <TH2F.h>
-#include <TList.h>
-#include <TIterator.h>
+#include "TH1F.h"
+#include "TH2F.h"
+#include "TList.h"
+#include "TIterator.h"
 #include "TParameter.h"
-#include <TMap.h>
-#include <TRandom.h>
-
-#include <AliTriggerAnalysis.h>
-
-#include <AliLog.h>
-#include <AliAnalysisManager.h>
-
-#include <AliESDEvent.h>
-
-#include <AliMultiplicity.h>
-#include <AliESDVZERO.h>
-#include <AliESDZDC.h>
-#include <AliESDFMD.h>
-#include <AliESDVertex.h>
-#include <AliESDtrackCuts.h>
-#include <AliDAQ.h>
-#include <AliESDTrdTrack.h>
+#include "TMap.h"
+#include "TRandom.h"
+#include "AliTriggerAnalysis.h"
+#include "AliLog.h"
+#include "AliVEvent.h"
+#include "AliESDEvent.h"
+#include "AliMultiplicity.h"
+#include "AliESDVZERO.h"
+#include "AliESDZDC.h"
+#include "AliESDFMD.h"
+#include "AliESDVertex.h"
+#include "AliESDtrackCuts.h"
+#include "AliDAQ.h"
+#include "AliESDTrdTrack.h"
+#include "AliVCaloTrigger.h"
 
 ClassImp(AliTriggerAnalysis)
 
 AliTriggerAnalysis::AliTriggerAnalysis() :
-  fSPDGFOThreshold(2),
-  fSPDGFOEfficiency(0),
-  fV0TimeOffset(0),
-  fV0AdcThr(0),
-  fV0HwAdcThr(2.5),
-  fV0HwWinLow(61.5),
-  fV0HwWinHigh(86.5),
-  fZDCCutRefSum(-568.5),
-  fZDCCutRefDelta(-2.1),
-  fZDCCutSigmaSum(3.25),
-  fZDCCutSigmaDelta(2.25),
-  fZDCCutRefSumCorr(-65.5),
-  fZDCCutRefDeltaCorr(-2.1),
-  fZDCCutSigmaSumCorr(6.0),
-  fZDCCutSigmaDeltaCorr(1.2),
-  fZDCCutZNATimeCorrMin(0.0),
-  fZDCCutZNATimeCorrMax(2.0),
-  fZDCCutZNCTimeCorrMin(0.0),
-  fZDCCutZNCTimeCorrMax(5.0),
-  fASPDCvsTCut(65),
-  fBSPDCvsTCut(4),
-  fTRDptHSE(3.),
-  fTRDpidHSE(144),
-  fTRDptHQU(2.),
-  fTRDpidHQU(164.),
-  fTRDptHEE(3.),
-  fTRDpidHEE(144),
-  fTRDminSectorHEE(6),
-  fTRDmaxSectorHEE(8),
-  fTRDptHJT(3.),
-  fTRDnHJT(3),
-  fDoFMD(kTRUE),
-  fFMDLowCut(0.2),
-  fFMDHitCut(0.5),
-  fHistBitsSPD(0),
-  fHistFiredBitsSPD(0),
-  fHistSPDClsVsTrk(0),
-  fHistV0A(0),       
-  fHistV0C(0),
-  fHistZDC(0),    
-  fHistTDCZDC(0),    
-  fHistTimeZDC(0),    
-  fHistTimeCorrZDC(0),    
-  fHistFMDA(0),    
-  fHistFMDC(0),   
-  fHistFMDSingle(0),
-  fHistFMDSum(0),
-  fHistT0(0),
-  fTriggerClasses(0),
-  fMC(kFALSE),
-  fEsdTrackCuts(0),
-  fTPCOnly(kFALSE)
+fSPDGFOThreshold(2),
+fSPDGFOEfficiency(0),
+fV0TimeOffset(0),
+fV0AdcThr(0),
+fV0HwAdcThr(2.5),
+fV0HwWinLow(61.5),
+fV0HwWinHigh(86.5),
+fZDCCutRefSum(-568.5),
+fZDCCutRefDelta(-2.1),
+fZDCCutSigmaSum(3.25),
+fZDCCutSigmaDelta(2.25),
+fZDCCutRefSumCorr(-65.5),
+fZDCCutRefDeltaCorr(-2.1),
+fZDCCutSigmaSumCorr(6.0),
+fZDCCutSigmaDeltaCorr(1.2),
+fZDCCutZNATimeCorrMin(0.0),
+fZDCCutZNATimeCorrMax(2.0),
+fZDCCutZNCTimeCorrMin(0.0),
+fZDCCutZNCTimeCorrMax(5.0),
+fASPDCvsTCut(65),
+fBSPDCvsTCut(4),
+fTRDptHSE(3.),
+fTRDpidHSE(144),
+fTRDptHQU(2.),
+fTRDpidHQU(164.),
+fTRDptHEE(3.),
+fTRDpidHEE(144),
+fTRDminSectorHEE(6),
+fTRDmaxSectorHEE(8),
+fTRDptHJT(3.),
+fTRDnHJT(3),
+fDoFMD(kTRUE),
+fFMDLowCut(0.2),
+fFMDHitCut(0.5),
+fHistBitsSPD(0),
+fHistFiredBitsSPD(0),
+fHistSPDClsVsTrk(0),
+fHistV0A(0),
+fHistV0C(0),
+fHistZDC(0),
+fHistTDCZDC(0),
+fHistTimeZDC(0),
+fHistTimeCorrZDC(0),
+fHistFMDA(0),
+fHistFMDC(0),
+fHistFMDSingle(0),
+fHistFMDSum(0),
+fHistT0(0),
+fTriggerClasses(0),
+fMC(kFALSE),
+fEsdTrackCuts(0),
+fTPCOnly(kFALSE)
 {
   // constructor
 }
 
-AliTriggerAnalysis::~AliTriggerAnalysis()
-{
+//-------------------------------------------------------------------------------------------------
+AliTriggerAnalysis::~AliTriggerAnalysis(){
   // destructor
-  
-  if (fHistBitsSPD)
-  {
-    delete fHistBitsSPD;
-    fHistBitsSPD = 0;
-  }
-
-  if (fHistFiredBitsSPD)
-  {
-    delete fHistFiredBitsSPD;
-    fHistFiredBitsSPD = 0;
-  }
-
-  if (fHistSPDClsVsTrk)
-  {
-    delete fHistSPDClsVsTrk;
-    fHistSPDClsVsTrk = 0;
-  }
-
-  if (fHistV0A)