Merge branch 'master' into TRDdev
authorshahoian <ruben.shahoyan@cern.ch>
Fri, 2 May 2014 14:15:37 +0000 (16:15 +0200)
committershahoian <ruben.shahoyan@cern.ch>
Fri, 2 May 2014 14:15:37 +0000 (16:15 +0200)
499 files changed:
AD/AliAD.cxx
AD/AliADReconstructor.cxx
ANALYSIS/AliCentralitySelectionTask.cxx
ANALYSIS/AliCentralitySelectionTask.h
ANALYSIS/AliUnfolding.cxx
ANALYSIS/TenderSupplies/AliPHOSTenderSupply.cxx
ANALYSIS/TenderSupplies/AliPHOSTenderSupply.h
ANALYSIS/macros/train/AddMCGenPythia8.C [new file with mode: 0644]
CMakeLists.txt
CORRFW/AliCFUnfolding.cxx
EVE/alice-macros/geom_mft.C [new file with mode: 0644]
EVGEN/AliGenEMCocktail.cxx
EVGEN/AliGenEMCocktail.h
EVGEN/AliGenEMlib.cxx
EVGEN/AliGenEMlib.h
EVGEN/AliGenParam.cxx
EVGEN/AliGenParam.h
FIT/AliFITRawData.cxx
FIT/AliFITReconstructor.cxx
FMD/AliFMDReconstructor.cxx
FMD/AliFMDReconstructor.h
ITS/AliITShit.h
ITS/UPGRADE/AliITSUClusterLines.cxx
ITS/UPGRADE/AliITSUClusterLines.h
ITS/UPGRADE/AliITSUSuze02.cxx
ITS/UPGRADE/AliITSUTrackerSA.cxx [new file with mode: 0755]
ITS/UPGRADE/AliITSUTrackerSA.h [new file with mode: 0755]
ITS/UPGRADE/AliITSUTrackerSAaux.h [new file with mode: 0755]
ITS/UPGRADE/AliITSUVertexer.cxx
ITS/UPGRADE/AliITSUVertexer.h
ITS/UPGRADE/AliITSUv0.cxx
ITS/UPGRADE/AliITSUv0.h
ITS/UPGRADE/AliITSUv1.cxx
ITS/UPGRADE/AliITSUv1.h
ITS/UPGRADE/CMakelibITSUpgradeRec.pkg [changed mode: 0644->0755]
ITS/UPGRADE/ITSUpgradeRecLinkDef.h [changed mode: 0644->0755]
ITS/UPGRADE/macros/AliITSUComparison.C [changed mode: 0644->0755]
ITS/UPGRADE/testITSU/Config.C
ITS/UPGRADE/testITSU/DetectorK.cxx
ITS/UPGRADE/testITSU/DetectorK.h
ITS/UPGRADE/testITSU/testDetectorUp.C
JETAN/AliAnalysisTaskJetCluster.cxx
JETAN/AliAnalysisTaskJetCluster.h
JETAN/AliJetFillCalTrkEvent.h
MFT/AliMFTAnalysisTools.cxx
MFT/AliMFTTrackerMU.cxx
MFT/CMakelibMFTbase.pkg
MICROCERN/CMakelibmicrocern.pkg
MONITOR/CMakeLists.txt
MONITOR/CMakebinalieventserver.pkg
MONITOR/CMakelibMONITOR.pkg
MONITOR/CMakelibMONITORzmq.pkg [new file with mode: 0644]
MONITOR/MONITORLinkDef.h
MONITOR/MONITORzmqLinkDef.h [new file with mode: 0644]
PWG/CMakelibPWGflowTasks.pkg
PWG/CaloTrackCorrBase/AliCaloTrackReader.cxx
PWG/CaloTrackCorrBase/AliCalorimeterUtils.cxx
PWG/CaloTrackCorrBase/AliCalorimeterUtils.h
PWG/DevNanoAOD/AliAnalysisTaskNanoAODFilter.cxx
PWG/EMCAL/AliAnalysisTaskEmcal.cxx
PWG/EMCAL/AliAnalysisTaskEmcal.h
PWG/EMCAL/macros/AddTaskEmcalPreparation.C
PWG/FLOW/Base/AliFlowAnalysisWithMultiparticleCorrelations.cxx
PWG/FLOW/Base/AliFlowAnalysisWithMultiparticleCorrelations.h
PWG/FLOW/Tasks/AliAnalysisTaskFlowStrange.cxx
PWG/FLOW/Tasks/AliAnalysisTaskFlowStrange.h
PWG/FLOW/Tasks/AliAnalysisTaskJetFlowMC.cxx
PWG/FLOW/Tasks/AliAnalysisTaskJetFlowMC.h
PWG/FLOW/Tasks/AliAnalysisTaskMultiparticleCorrelations.cxx
PWG/FLOW/Tasks/AliAnalysisTaskMultiparticleCorrelations.h
PWG/FLOW/Tasks/AliJetFlowTools.cxx
PWG/FLOW/Tasks/AliJetFlowTools.h
PWG/PWGflowTasksLinkDef.h
PWG/TRD/AliTRDTriggerAnalysis.cxx
PWG/TRD/AliTRDTriggerAnalysis.h
PWG/muon/AliAnalysisMuonUtility.cxx
PWG/muon/AliAnalysisTaskESDMuonFilter.cxx
PWG/muon/AliAnalysisTaskSingleMu.cxx
PWG/muon/AliMuonEventCuts.cxx
PWG/muon/AliMuonEventCuts.h
PWG/muondep/AccEffTemplates/GenPythia8.C [new file with mode: 0644]
PWG/muondep/rootlogon.C [new file with mode: 0644]
PWGCF/CMakelibPWGCFChaoticity.pkg
PWGCF/CMakelibPWGCFCorrelationsBase.pkg
PWGCF/CMakelibPWGCFCorrelationsDPhi.pkg
PWGCF/CMakelibPWGCFK0Analysis.pkg
PWGCF/CMakelibPWGCFfemtoscopy.pkg
PWGCF/CMakelibPWGCFfemtoscopyUser.pkg
PWGCF/Correlations/Base/AliTwoPlusOneContainer.cxx [new file with mode: 0644]
PWGCF/Correlations/Base/AliTwoPlusOneContainer.h [new file with mode: 0644]
PWGCF/Correlations/Base/AliUEHist.cxx
PWGCF/Correlations/Base/AliUEHist.h
PWGCF/Correlations/Base/AliUEHistograms.cxx
PWGCF/Correlations/DPhi/AliAnalysisTaskPhiCorrelations.cxx
PWGCF/Correlations/DPhi/AliAnalysisTaskTwoPlusOne.cxx [new file with mode: 0644]
PWGCF/Correlations/DPhi/AliAnalysisTaskTwoPlusOne.h [new file with mode: 0644]
PWGCF/Correlations/DPhi/AliLeadingV0Correlation.cxx
PWGCF/Correlations/DPhi/AliLeadingV0Correlation.h
PWGCF/Correlations/DPhi/DiHadronPID/AliHistToolsDiHadronPID.h
PWGCF/Correlations/DPhi/TriggerPID/AliTwoParticlePIDCorr.cxx
PWGCF/Correlations/DPhi/TriggerPID/AliTwoParticlePIDCorr.h
PWGCF/Correlations/macros/AddTaskLV0Correlation.C
PWGCF/Correlations/macros/AddTaskLongRangeCorrelations.C
PWGCF/Correlations/macros/twoplusone/AddTaskTwoPlusOne.C [new file with mode: 0644]
PWGCF/Correlations/macros/twoplusone/output_TwoPlusOne.C [new file with mode: 0644]
PWGCF/EBYE/BalanceFunctions/AliBalancePsi.cxx
PWGCF/EBYE/BalanceFunctions/AliBalancePsi.h
PWGCF/EBYE/NetParticle/eff/effectiveCorrection.root [deleted file]
PWGCF/EBYE/macros/drawBalanceFunction2DPsi.C
PWGCF/EBYE/macros/drawCorrelationFunctionPsi.C
PWGCF/FEMTOSCOPY/AliFemto/AliFemtoEventReaderAOD.cxx
PWGCF/FEMTOSCOPY/AliFemto/AliFemtoEventReaderAOD.h
PWGCF/FEMTOSCOPY/AliFemto/AliFemtoEventReaderESDChain.cxx
PWGCF/FEMTOSCOPY/AliFemto/AliFemtoEventReaderESDChain.h
PWGCF/FEMTOSCOPY/AliFemto/AliFemtoEventReaderKinematicsChainESD.cxx
PWGCF/FEMTOSCOPY/AliFemto/AliFemtoEventReaderKinematicsChainESD.h
PWGCF/FEMTOSCOPY/AliFemto/AliFemtoTrack.cxx
PWGCF/FEMTOSCOPY/AliFemto/AliFemtoTrack.h
PWGCF/FEMTOSCOPY/AliFemtoUser/AliFemtoCorrFctnDEtaDPhi.cxx
PWGCF/FEMTOSCOPY/AliFemtoUser/AliFemtoCorrFctnMinvMonitor.cxx [new file with mode: 0644]
PWGCF/FEMTOSCOPY/AliFemtoUser/AliFemtoCorrFctnMinvMonitor.h [new file with mode: 0644]
PWGCF/FEMTOSCOPY/AliFemtoUser/AliFemtoESDTrackCut.cxx
PWGCF/FEMTOSCOPY/AliFemtoUser/AliFemtoESDTrackCut.h
PWGCF/FEMTOSCOPY/AliFemtoUser/AliFemtoModelBPLCMSCorrFctn.cxx
PWGCF/FEMTOSCOPY/AliFemtoUser/AliFemtoPairCutRadialDistance.cxx
PWGCF/FEMTOSCOPY/AliFemtoUser/AliFemtoPairCutRadialDistance.h
PWGCF/FEMTOSCOPY/AliFemtoUser/AliFemtoPairCutResonances.cxx [new file with mode: 0644]
PWGCF/FEMTOSCOPY/AliFemtoUser/AliFemtoPairCutResonances.h [new file with mode: 0644]
PWGCF/FEMTOSCOPY/Chaoticity/AliChaoticity.cxx
PWGCF/FEMTOSCOPY/K0Analysis/AliFemtoK0Analysis.cxx
PWGCF/FEMTOSCOPY/K0Analysis/AliFemtoK0Analysis.h
PWGCF/FEMTOSCOPY/K0Analysis/AliFemtoK0EventCollection.cxx
PWGCF/FEMTOSCOPY/K0Analysis/AliFemtoK0EventCollection.h
PWGCF/FEMTOSCOPY/macros/AddTaskK0Femto.C
PWGCF/FEMTOSCOPY/macros/Train/KchHBT_PID0520/05/AddTaskFemto.C [new file with mode: 0644]
PWGCF/FEMTOSCOPY/macros/Train/KchHBT_PID0520/05/ConfigFemtoAnalysis.C [new file with mode: 0644]
PWGCF/FEMTOSCOPY/macros/Train/KchHBT_PID0520/20/AddTaskFemto.C [new file with mode: 0644]
PWGCF/FEMTOSCOPY/macros/Train/KchHBT_PID0520/20/ConfigFemtoAnalysis.C [new file with mode: 0644]
PWGCF/FEMTOSCOPY/macros/Train/KchHBT_PID0520/dca/AddTaskFemto.C [new file with mode: 0644]
PWGCF/FEMTOSCOPY/macros/Train/KchHBT_PID0520/dca/ConfigFemtoAnalysis.C [new file with mode: 0644]
PWGCF/FEMTOSCOPY/macros/Train/KchHBT_PID20/All/V0A/ConfigFemtoAnalysis.C
PWGCF/FEMTOSCOPY/macros/Train/KchHBT_PID20/All/V0M/ConfigFemtoAnalysis.C
PWGCF/FEMTOSCOPY/macros/Train/KchHBT_PID20/Kaons/V0A/ConfigFemtoAnalysis.C
PWGCF/FEMTOSCOPY/macros/Train/KchHBT_PID20/Kaons/V0M/ConfigFemtoAnalysis.C
PWGCF/FEMTOSCOPY/macros/Train/MC_KK_pPb_V0M/AddTaskFemto.C [new file with mode: 0644]
PWGCF/FEMTOSCOPY/macros/Train/MC_KK_pPb_V0M/ConfigFemtoAnalysis.C [new file with mode: 0644]
PWGCF/FLOW/Attic/AliAnalysisTaskJetFlow.cxx [moved from PWG/FLOW/Tasks/AliAnalysisTaskJetFlow.cxx with 100% similarity]
PWGCF/FLOW/Attic/AliAnalysisTaskJetFlow.h [moved from PWG/FLOW/Tasks/AliAnalysisTaskJetFlow.h with 100% similarity]
PWGCF/FLOW/Attic/AliAnalysisTaskMSP.cxx [moved from PWG/FLOW/Tasks/AliAnalysisTaskMSP.cxx with 100% similarity]
PWGCF/FLOW/Attic/AliAnalysisTaskMSP.h [moved from PWG/FLOW/Tasks/AliAnalysisTaskMSP.h with 100% similarity]
PWGCF/FLOW/Attic/AliFlowAnalysisWithMSP.cxx [moved from PWG/FLOW/Base/AliFlowAnalysisWithMSP.cxx with 100% similarity]
PWGCF/FLOW/Attic/AliFlowAnalysisWithMSP.h [moved from PWG/FLOW/Base/AliFlowAnalysisWithMSP.h with 100% similarity]
PWGCF/FLOW/Attic/AliFlowMSPHistograms.cxx [moved from PWG/FLOW/Base/AliFlowMSPHistograms.cxx with 100% similarity]
PWGCF/FLOW/Attic/AliFlowMSPHistograms.h [moved from PWG/FLOW/Base/AliFlowMSPHistograms.h with 100% similarity]
PWGCF/FLOW/macros/AddTaskFlowStrange.C
PWGCF/FLOW/macros/AddTaskPIDFlowQC.C [new file with mode: 0644]
PWGCF/FLOW/macros/AddTaskPIDFlowSP.C [new file with mode: 0644]
PWGCF/PWGCFCorrelationsBaseLinkDef.h
PWGCF/PWGCFCorrelationsDPhiLinkDef.h
PWGCF/PWGCFfemtoscopyUserLinkDef.h
PWGDQ/dielectron/AliDielectron.cxx
PWGDQ/dielectron/AliDielectron.h
PWGDQ/dielectron/AliDielectronBtoJPSItoEleCDFfitFCN.cxx
PWGDQ/dielectron/AliDielectronBtoJPSItoEleCDFfitFCN.h
PWGDQ/dielectron/AliDielectronEventCuts.cxx
PWGDQ/dielectron/AliDielectronEventCuts.h
PWGDQ/dielectron/AliDielectronHistos.cxx
PWGDQ/dielectron/AliDielectronMixingHandler.cxx
PWGDQ/dielectron/AliDielectronPID.cxx
PWGDQ/dielectron/AliDielectronVarManager.cxx
PWGDQ/dielectron/AliDielectronVarManager.h
PWGDQ/dielectron/macrosJPSI/AddTaskJPSIFilter.C
PWGDQ/dielectron/macrosJPSI/AddTask_jbook_JPsi.C
PWGDQ/dielectron/macrosJPSI/ConfigJpsi_nano_PbPb.C
PWGGA/CMakelibPWGGAEMCALTasks.pkg
PWGGA/CMakelibPWGGAPHOSTasks.pkg
PWGGA/CaloTrackCorrelations/AliAnaCalorimeterQA.cxx
PWGGA/CaloTrackCorrelations/AliAnaCalorimeterQA.h
PWGGA/CaloTrackCorrelations/AliAnaInsideClusterInvariantMass.cxx
PWGGA/CaloTrackCorrelations/AliAnaInsideClusterInvariantMass.h
PWGGA/CaloTrackCorrelations/AliAnaParticleIsolation.cxx
PWGGA/CaloTrackCorrelations/AliAnaParticleIsolation.h
PWGGA/CaloTrackCorrelations/AliAnaPhoton.cxx
PWGGA/CaloTrackCorrelations/AliAnaPhoton.h
PWGGA/CaloTrackCorrelations/AliAnaPi0.cxx
PWGGA/CaloTrackCorrelations/AliAnaPi0.h
PWGGA/CaloTrackCorrelations/AliAnaPi0EbE.cxx
PWGGA/CaloTrackCorrelations/AliAnaPi0EbE.h
PWGGA/CaloTrackCorrelations/macros/AddTaskCaloTrackCorr.C
PWGGA/CaloTrackCorrelations/macros/AddTaskCaloTrackCorrM.C
PWGGA/CaloTrackCorrelations/macros/AddTaskCounter.C
PWGGA/CaloTrackCorrelations/macros/AddTaskIsoPhoton.C [new file with mode: 0644]
PWGGA/CaloTrackCorrelations/macros/AddTaskPi0.C
PWGGA/CaloTrackCorrelations/macros/AddTaskPi0EMCALPbPb.C
PWGGA/CaloTrackCorrelations/macros/AddTaskShowerShapeStudies.C
PWGGA/CaloTrackCorrelations/macros/QA/AddTaskCalorimeterQA.C
PWGGA/CaloTrackCorrelations/macros/QA/AddTaskPi0IMGammaCorrQA.C
PWGGA/EMCALTasks/AliAnalysisTaskEMCALIsoPhoton.cxx
PWGGA/EMCALTasks/AliAnalysisTaskEMCALIsoPhoton.h
PWGGA/EMCALTasks/AliAnalysisTaskEMCALMesonGGSDM.cxx [new file with mode: 0644]
PWGGA/EMCALTasks/AliAnalysisTaskEMCALMesonGGSDM.h [new file with mode: 0644]
PWGGA/EMCALTasks/AliAnalysisTaskEMCALMesonGGSDMpPb.cxx [new file with mode: 0644]
PWGGA/EMCALTasks/AliAnalysisTaskEMCALMesonGGSDMpPb.h [new file with mode: 0644]
PWGGA/EMCALTasks/AliAnalysisTaskSDMGammaMC.cxx [new file with mode: 0644]
PWGGA/EMCALTasks/AliAnalysisTaskSDMGammaMC.h [new file with mode: 0644]
PWGGA/EMCALTasks/macros/AddTaskEMCALIsoPhoton.C
PWGGA/EMCALTasks/macros/AddTaskEMCALMesonGGSDM.C [new file with mode: 0644]
PWGGA/EMCALTasks/macros/AddTaskEMCALMesonGGSDMpPb.C [new file with mode: 0644]
PWGGA/EMCALTasks/macros/AddTaskSDMGammaMC.C [new file with mode: 0644]
PWGGA/GammaConv/AliAnalysisTaskGammaConvDalitzV1.cxx
PWGGA/GammaConv/AliAnalysisTaskGammaConvDalitzV1.h
PWGGA/GammaConv/AliAnalysisTaskGammaConvV1.cxx
PWGGA/GammaConv/AliAnalysisTaskGammaConvV1.h
PWGGA/GammaConv/AliConversionCuts.cxx
PWGGA/GammaConv/AliConversionCuts.h
PWGGA/GammaConv/AliDalitzElectronCuts.cxx
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_PbPb2.C
PWGGA/GammaConv/macros/AddTask_GammaConvV1_pPb.C
PWGGA/GammaConv/macros/AddTask_GammaConvV1_pp.C
PWGGA/PHOSTasks/PHOS_Correlation/AddTaskPi0Correlations.C [new file with mode: 0644]
PWGGA/PHOSTasks/PHOS_Correlation/AliPHOSCorrelations.cxx [new file with mode: 0644]
PWGGA/PHOSTasks/PHOS_Correlation/AliPHOSCorrelations.h [new file with mode: 0644]
PWGGA/PWGGAEMCALTasksLinkDef.h
PWGGA/PWGGAPHOSTasksLinkDef.h
PWGHF/CMakelibPWGHFcorrelationHF.pkg
PWGHF/correlationHF/AliHFDhadronCorrSystUnc.cxx [new file with mode: 0644]
PWGHF/correlationHF/AliHFDhadronCorrSystUnc.h [new file with mode: 0644]
PWGHF/hfe/AliAnalysisTaskFlowITSTPCTOFQCSP.cxx
PWGHF/hfe/AliAnalysisTaskFlowITSTPCTOFQCSP.h
PWGHF/hfe/AliAnalysisTaskFlowTPCEMCalQCSP.cxx
PWGHF/hfe/AliAnalysisTaskHFECal.cxx
PWGHF/hfe/AliHFEV0taginfo.cxx
PWGHF/hfe/AliHFEV0taginfo.h
PWGHF/hfe/AliHFEmcQA.cxx
PWGHF/hfe/AliHFEmcQA.h
PWGHF/hfe/macros/AddTaskFlowITSTPCTOFQCSP.C
PWGHF/vertexingHF/AliAnalysisTaskSEDvsMultiplicity.cxx
PWGHF/vertexingHF/AliAnalysisTaskSEDvsMultiplicity.h
PWGHF/vertexingHF/AliAnalysisTaskSELc2V0bachelor.cxx
PWGHF/vertexingHF/AliAnalysisTaskSELc2V0bachelorTMVA.cxx [changed mode: 0644->0755]
PWGHF/vertexingHF/AliAnalysisTaskSELc2V0bachelorTMVA.h [changed mode: 0644->0755]
PWGHF/vertexingHF/AliCFTaskVertexingHF.cxx
PWGHF/vertexingHF/AliCFTaskVertexingHF.h
PWGHF/vertexingHF/AliCFVertexingHF2Prong.cxx
PWGHF/vertexingHF/AliCFVertexingHF3Prong.cxx
PWGHF/vertexingHF/AliCFVertexingHFCascade.cxx
PWGHF/vertexingHF/AliHFSystErr.cxx
PWGHF/vertexingHF/AliHFSystErr.h
PWGHF/vertexingHF/macros/AddTaskCFVertexingHF3Prong.C
PWGHF/vertexingHF/macros/AddTaskCFVertexingHF3ProngDs.C
PWGHF/vertexingHF/macros/DrawFpromptVsRaaElossHypoCombined.C [new file with mode: 0644]
PWGJE/AliAnalysisTaskFragmentationFunction.cxx
PWGJE/AliAnalysisTaskFragmentationFunction.h
PWGJE/AliAnalysisTaskJetCorePP.cxx
PWGJE/AliAnalysisTaskJetProperties.cxx
PWGJE/AliAnalysisTaskJetProperties.h
PWGJE/AliAnalysisTaskJetSpectrum2.cxx
PWGJE/AliAnalysisTaskJetSpectrum2.h
PWGJE/AliPWG4HighPtSpectra.cxx
PWGJE/AliPWG4HighPtSpectra.h
PWGJE/CMakelibPWGJE.pkg
PWGJE/EMCALJetTasks/AliAnalysisTaskDeltaPt.cxx
PWGJE/EMCALJetTasks/AliAnalysisTaskScale.cxx
PWGJE/EMCALJetTasks/AliAnalysisTaskScale.h
PWGJE/EMCALJetTasks/AliJetResponseMaker.cxx
PWGJE/EMCALJetTasks/AliJetResponseMaker.h
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskChargedJetsPA.cxx
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskEmcalJetHadEPpid.cxx
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskEmcalJetHadEPpid.h
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskEmcalJetPatchTriggerQA.cxx
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskEmcalJetSpectra.cxx
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskEmcalJetTriggerQA.cxx
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskEmcalJetTriggerQA.h
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskFullpAJets.cxx
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskFullpAJets.h
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskHJetDphi.cxx
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskHJetDphi.h
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskRhoVnModulation.cxx
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskRhoVnModulation.h
PWGJE/EMCALJetTasks/macros/AddTaskChargedJetsPA.C
PWGJE/EMCALJetTasks/macros/AddTaskEmcalJetHadEPpid.C
PWGJE/EMCALJetTasks/macros/AddTaskFullpAJets.C
PWGJE/FlavourJetTasks/AliAnalysisTaskFlavourJetCorrelations.cxx
PWGJE/FlavourJetTasks/AliAnalysisTaskFlavourJetCorrelations.h
PWGJE/FlavourJetTasks/macros/AddTaskDFilterAndCorrelations.C
PWGJE/PWGJELinkDef.h
PWGJE/PWGJEStrangenessInJetsLinkDef.h
PWGJE/StrangenessInJets/AliAnalysisTaskJetChem.cxx
PWGJE/StrangenessInJets/AliAnalysisTaskJetChem.h
PWGJE/StrangenessInJets/AliAnalysisTaskV0sInJets.cxx
PWGJE/StrangenessInJets/AliAnalysisTaskV0sInJets.h
PWGJE/StrangenessInJets/macros/AddTaskJetChem.C
PWGJE/UserTasks/AliAnalysisTaskIDFFTCF.cxx
PWGJE/UserTasks/AliAnalysisTaskIDFFTCF.h
PWGJE/UserTasks/AliAnalysisTaskJetProtonCorr.cxx
PWGJE/UserTasks/AliAnalysisTaskJetProtonCorr.h
PWGJE/UserTasks/AliAnalysisTaskJetsTriggerTRD.h
PWGJE/UserTasks/AliAnalysisTaskPID.cxx
PWGJE/UserTasks/AliAnalysisTaskPID.h
PWGJE/UserTasks/AliAnalysisTaskPPJetSpectra.cxx [new file with mode: 0755]
PWGJE/UserTasks/AliAnalysisTaskPPJetSpectra.h [new file with mode: 0755]
PWGJE/UserTasks/AliIDFFUtils.cxx
PWGJE/UserTasks/AliIDFFUtils.h
PWGJE/macros/AddTaskJetCorePP.C
PWGJE/macros/AddTaskJetProperties.C
PWGJE/macros/AddTaskPPJetSpectra.C [new file with mode: 0755]
PWGJE/macros/AddTaskPWG4HighPtSpectra.C
PWGJE/macros/AddTaskPWG4HighPtTrackQA.C
PWGJE/macros/loadlibPWGJE.C [new file with mode: 0644]
PWGLF/CMakelibPWGLFforward2.pkg
PWGLF/FORWARD/analysis2/AddTaskCentraldNdeta.C
PWGLF/FORWARD/analysis2/AddTaskForwardQA.C
PWGLF/FORWARD/analysis2/AddTaskForwarddNdeta.C
PWGLF/FORWARD/analysis2/AliBasedNdetaTask.cxx
PWGLF/FORWARD/analysis2/AliBasedNdetaTask.h
PWGLF/FORWARD/analysis2/AliFMDCorrELossFit.cxx
PWGLF/FORWARD/analysis2/AliFMDCorrELossFit.h
PWGLF/FORWARD/analysis2/AliFMDEnergyFitter.cxx
PWGLF/FORWARD/analysis2/AliFMDEnergyFitter.h
PWGLF/FORWARD/analysis2/AliFMDHistCollector.cxx
PWGLF/FORWARD/analysis2/AliFMDMCHitEnergyFitterTask.h
PWGLF/FORWARD/analysis2/AliFMDMultCuts.cxx
PWGLF/FORWARD/analysis2/AliFMDMultCuts.h
PWGLF/FORWARD/analysis2/AliFMDSharingFilter.cxx
PWGLF/FORWARD/analysis2/AliForwardMCMultiplicityTask.cxx
PWGLF/FORWARD/analysis2/AliForwardMCMultiplicityTask.h
PWGLF/FORWARD/analysis2/AliForwardMultiplicityBase.cxx
PWGLF/FORWARD/analysis2/AliForwardMultiplicityBase.h
PWGLF/FORWARD/analysis2/AliForwardUtil.cxx
PWGLF/FORWARD/analysis2/AliForwardUtil.h
PWGLF/FORWARD/analysis2/AliLandauGaus.h [new file with mode: 0644]
PWGLF/FORWARD/analysis2/AliLandauGausFitter.h [new file with mode: 0644]
PWGLF/FORWARD/analysis2/DrawAODSummary.C
PWGLF/FORWARD/analysis2/DrawMCCorrSummary.C
PWGLF/FORWARD/analysis2/DrawMultDistsSummary.C
PWGLF/FORWARD/analysis2/DrawdNdeta.C
PWGLF/FORWARD/analysis2/DrawdNdetaSummary.C
PWGLF/FORWARD/analysis2/ForwardAODConfig.C
PWGLF/FORWARD/analysis2/corrs/CorrDrawer.C
PWGLF/FORWARD/analysis2/corrs/DrawCorrELoss.C
PWGLF/FORWARD/analysis2/corrs/DrawCorrSecMap.C
PWGLF/FORWARD/analysis2/corrs/DrawMultCuts.C [new file with mode: 0644]
PWGLF/FORWARD/analysis2/corrs/MultCutDrawer.C [new file with mode: 0644]
PWGLF/FORWARD/analysis2/corrs/Outliers.C [new file with mode: 0644]
PWGLF/FORWARD/analysis2/corrs/PDFLandau.C [new file with mode: 0644]
PWGLF/FORWARD/analysis2/corrs/Reference.C [new file with mode: 0644]
PWGLF/FORWARD/analysis2/corrs/RerunELossFits.C
PWGLF/FORWARD/analysis2/corrs/RunTestF.C [new file with mode: 0644]
PWGLF/FORWARD/analysis2/corrs/TestF.C [new file with mode: 0644]
PWGLF/FORWARD/analysis2/corrs/WrappedGraph.C [new file with mode: 0644]
PWGLF/FORWARD/analysis2/qa/FMD.sh [new file with mode: 0644]
PWGLF/FORWARD/analysis2/qa/PeriodQA.C [new file with mode: 0644]
PWGLF/FORWARD/analysis2/qa/QABase.h
PWGLF/FORWARD/analysis2/qa/QAPlotter.C
PWGLF/FORWARD/analysis2/qa/QATrender.C
PWGLF/FORWARD/analysis2/qa/RunQA.C
PWGLF/FORWARD/analysis2/qa/RunQAMT.sh
PWGLF/FORWARD/analysis2/qa/RunQAOld.C [new file with mode: 0644]
PWGLF/FORWARD/analysis2/qa/RunQAOld.sh [moved from PWGLF/FORWARD/analysis2/qa/RunQA.sh with 99% similarity]
PWGLF/FORWARD/analysis2/qa/makeIndex.sh [new file with mode: 0755]
PWGLF/FORWARD/analysis2/qa/periodQA.sh [new file with mode: 0755]
PWGLF/FORWARD/analysis2/qa/runQA.sh [new file with mode: 0755]
PWGLF/FORWARD/analysis2/qa/script.js [new file with mode: 0644]
PWGLF/FORWARD/analysis2/qa/style.css
PWGLF/FORWARD/analysis2/scan/ForwardAODConfig.C.in [new file with mode: 0644]
PWGLF/FORWARD/analysis2/scan/MakeTrend.C [new file with mode: 0644]
PWGLF/FORWARD/analysis2/scan/Trend.C [new file with mode: 0644]
PWGLF/FORWARD/analysis2/scan/allScan.sh [new file with mode: 0755]
PWGLF/FORWARD/analysis2/scan/baseScan.sh [new file with mode: 0644]
PWGLF/FORWARD/analysis2/scan/collectdNdeta.sh [new file with mode: 0755]
PWGLF/FORWARD/analysis2/scan/dcScan.sh [new file with mode: 0755]
PWGLF/FORWARD/analysis2/scan/shScan.sh [new file with mode: 0755]
PWGLF/FORWARD/analysis2/scan/slScan.sh [new file with mode: 0755]
PWGLF/FORWARD/analysis2/scripts/SummaryAODDrawer.C
PWGLF/FORWARD/analysis2/scripts/SummaryDrawer.C
PWGLF/FORWARD/analysis2/scripts/SummaryMCCorrDrawer.C
PWGLF/FORWARD/analysis2/scripts/SummarydNdetaDrawer.C
PWGLF/FORWARD/analysis2/scripts/getGridData.sh
PWGLF/FORWARD/analysis2/trains/MakeAODTrain.C
PWGLF/FORWARD/analysis2/trains/MakeFMDELossTrain.C
PWGLF/FORWARD/analysis2/trains/MakeMCCorrTrain.C
PWGLF/FORWARD/analysis2/trains/MakedNdetaTrain.C
PWGLF/FORWARD/doc/landgaus.tex [new file with mode: 0644]
PWGLF/FORWARD/trains/ChainBuilder.C
PWGLF/FORWARD/trains/CreateFileCollection.C
PWGLF/FORWARD/trains/CreateIndex.C
PWGLF/FORWARD/trains/Helper.C
PWGLF/PWGLFforward2LinkDef.h
PWGLF/RESONANCES/AliRsnCutV0.cxx
PWGLF/RESONANCES/AliRsnMiniAnalysisTask.cxx
PWGLF/RESONANCES/AliRsnMiniAnalysisTask.h
PWGLF/RESONANCES/AliRsnMiniOutput.cxx
PWGLF/RESONANCES/AliRsnMiniOutput.h
PWGLF/RESONANCES/AliRsnMiniPair.cxx
PWGLF/RESONANCES/AliRsnMiniPair.h
PWGLF/RESONANCES/AliRsnMiniParticle.cxx
PWGLF/RESONANCES/AliRsnMiniParticle.h
PWGLF/RESONANCES/AliRsnValueDaughter.cxx
PWGLF/RESONANCES/AliRsnValueDaughter.h
PWGLF/RESONANCES/macros/mini/AddAnalysisTaskD0.C
PWGLF/RESONANCES/macros/mini/AddTaskSigmaStar.C
PWGLF/RESONANCES/macros/mini/ConfigD0.C
PWGLF/RESONANCES/macros/mini/ConfigSigmaStar.C
PWGLF/SPECTRA/ChargedHadrons/dNdPt/AlidNdPtAnalysisPbPbAOD.cxx
PWGLF/SPECTRA/ChargedHadrons/dNdPt/AlidNdPtAnalysisPbPbAOD.h
PWGLF/SPECTRA/ChargedHadrons/dNdPt/macros/AddTask_dNdPt_PbPbAOD.C
PWGLF/SPECTRA/Nuclei/masses/AliAnalysisNucleiMass.cxx
PWGLF/SPECTRA/PiKaPr/TPCTOF/AliAnalysisCombinedHadronSpectra.cxx
PWGLF/SPECTRA/PiKaPr/TPCTOF/AliAnalysisCombinedHadronSpectra.h
PWGLF/SPECTRA/PiKaPr/TestAOD/AliAnalysisTaskSpectraAllChAOD.cxx
PWGLF/SPECTRA/PiKaPr/TestAOD/AnalysisBoth.C
PWGLF/STRANGENESS/Cascades/AliAnalysisTaskExtractPerformanceCascade.cxx
PWGLF/STRANGENESS/Cascades/AliAnalysisTaskExtractPerformanceCascade.h
PWGLF/STRANGENESS/Correlations/AliAnalysisTaskLambdaOverK0sJets.cxx
PWGLF/STRANGENESS/Correlations/AliAnalysisTaskLambdaOverK0sJets.h
PWGLF/STRANGENESS/Correlations/macros/AddTaskLambdaOverK0sJets.C
PWGLF/STRANGENESS/Hypernuclei/AliAnalysisTaskAntiHe4.cxx
PWGLF/STRANGENESS/Hypernuclei/AliAnalysisTaskAntiHe4.h
PWGLF/STRANGENESS/Hypernuclei/AliAnalysisTaskHelium3PiAOD.cxx
PWGLF/STRANGENESS/Hypernuclei/AliAnalysisTaskReadNuclexAOD.cxx
PWGLF/STRANGENESS/LambdaK0PbPb/AddTaskV0ForRAA.C
PWGLF/ThermalFits/AliParticleYield.cxx
PWGLF/ThermalFits/AliParticleYield.h
PWGLF/ThermalFits/AverageAndExtrapolate.C [new file with mode: 0644]
PWGLF/ThermalFits/FitNPartDependence.C [new file with mode: 0644]
PWGLF/ThermalFits/InterpolateRatiosAndYields.C [new file with mode: 0644]
PWGLF/ThermalFits/PlotRatiosForQM14.C [new file with mode: 0644]
PWGLF/totEt/AliAnalysisEtSelector.cxx
PWGLF/totEt/AliAnalysisEtSelector.h
PWGPP/AliAnalysisTaskFilteredTree.cxx
PWGPP/AliAnalysisTaskFilteredTree.h
PWGPP/AliTaskCDBconnect.cxx
PWGPP/CalibMacros/CPass0/mergeMakeOCDB.byComponent.sh [changed mode: 0755->0644]
PWGPP/CalibMacros/CPass0/runCPass0.sh
PWGPP/CalibMacros/CPass1/mergeMakeOCDB.byComponent.sh [changed mode: 0755->0644]
PWGPP/CalibMacros/CPass1/runCPass1.sh
PWGPP/EVCHAR/GlauberSNM/GlauberMC_pPb_ntuple_sigma70_mind4_r662_a546_Rpro6.root [deleted file]
PWGPP/QA/detectorQAscripts/EXAMPLE.sh.template
PWGPP/QA/detectorQAscripts/T0.sh
PWGPP/QA/detectorQAscripts/TOF.sh
PWGPP/QA/detectorQAscripts/TPC.sh
PWGPP/QA/detectorQAscripts/TRK.sh
PWGPP/QA/scripts/runQA.example.config
PWGPP/QA/scripts/runQA.sh
PWGPP/TOF/trending/MakeTrendingTOFQA.C
PWGPP/benchmark/benchmark.config
PWGPP/benchmark/benchmark.sh
PWGUD/DIFFRACTIVE/xsAndTwoProng/AliCDMesonUtils.cxx
PWGUD/DIFFRACTIVE/xsAndTwoProng/AliCDMesonUtils.h
PWGUD/UPC/AddTaskUpcPsi2s.C
PWGUD/UPC/AliAnalysisTaskUpcPsi2s.cxx
PWGUD/UPC/AliAnalysisTaskUpcPsi2s.h
PYTHIA6/AliGenPythia.cxx
PYTHIA6/AliGenPythia.h
PYTHIA8/AliPythia8.cxx
RAW/AliRawEventHeaderVersions.h
SHUTTLE/schema/ACO.ldif
SHUTTLE/schema/TRD.ldif
SHUTTLE/schema_prod/ACO.ldif
SHUTTLE/schema_prod/TRD.ldif
STAT/TKDInterpolatorBase.h
STEER/AOD/AliAODCaloCluster.cxx
STEER/AOD/AliAODCaloCluster.h
STEER/AOD/AliAODTrack.cxx
STEER/AODLinkDef.h
STEER/CDB/AliCDBLocal.cxx
STEER/ESD/AliESDCaloCluster.cxx
STEER/ESD/AliESDCaloCluster.h
STEER/ESD/AliESDMuonGlobalTrack.cxx
STEER/ESD/AliESDMuonGlobalTrack.h
STEER/ESD/AliESDtrack.cxx
STEER/STEER/AliReconstruction.cxx
STEER/STEERBase/AliExternalTrackParam.cxx
STEER/STEERBase/AliExternalTrackParam.h
STEER/STEERBase/AliVCluster.h
T0/AliT0CalibWalk.cxx
T0/CMakelibT0calib.pkg
T0/MakeTrendT0.C
TOF/AliTOFDecoder.cxx
TOF/macrosQA/MakeTrendingTOFQA.C
TPC/Base/AliTPCCorrection.cxx
TPC/Base/AliTPCCorrection.h
TPC/Rec/AliTPCtracker.cxx
TPC/Rec/AliTPCtracker.h
TPC/Upgrade/AliToyMCEventGeneratorSimple.cxx
TPC/Upgrade/AliToyMCEventGeneratorSimple.h
TPC/Util/AliTPCCalibQAChecker.cxx
TPC/Util/AliTPCCalibQAChecker.h
TRD/AliTRDdEdxBaseUtils.cxx
TRD/AliTRDdEdxBaseUtils.h
TRD/AliTRDtrackOnline.cxx
TRD/AliTRDtrackOnline.h
VZERO/CheckCalibOCDB.C
cmake/ALICE_CMake.cmake
cmake/CMakemacosx64.cmake
cmake/FindROOT.cmake

index d370296a5fc2519a83c142cc7331523c2419bb50..ecac3bdf2d4fe68c4c06765b6497b0b00a42cc01 100644 (file)
@@ -263,7 +263,7 @@ void AliAD::Digits2Raw()
 
 //_____________________________________________________________________________
 
-Bool_t AliAD::Raw2SDigits(AliRawReader* rawReader)
+Bool_t AliAD::Raw2SDigits(AliRawReader* /*rawReader*/)
 {
        // reads raw data to produce digits
        // for AD not implemented yet (needs detailed hardware info)
index ddc2dc29c55074a4dffc06b93d45c92d56b740a9..a87acfdcb4fc6e8930d798fc2266171d1139a2c8 100644 (file)
@@ -63,7 +63,7 @@ void AliADReconstructor::Init()
     fESDAD  = new AliESDAD;
 }
 
-void AliADReconstructor::ConvertDigits(AliRawReader* rawReader, TTree* digitsTree) const
+void AliADReconstructor::ConvertDigits(AliRawReader* /*rawReader*/, TTree* /*digitsTree*/) const
 {
 
   printf("Converting digits for AD .. not implemented \n");
index 8f9de8990490e692fc2367c13c2ab5f193f09d2c..5ed0f71f40791270aa49a882b88cff37841763db 100644 (file)
@@ -1278,15 +1278,16 @@ void AliCentralitySelectionTask::UserExec(Option_t */*option*/)
   // Equalized signals
   multV0AEq=0.;
   multV0CEq=0.;
-  for(Int_t iCh = 4; iCh < 7; ++iCh) {
-    Double_t mult = esd->GetVZEROEqMultiplicity(iCh);
-    multV0AEq += mult;
-  }
-  for(Int_t iCh = 0; iCh < 3; ++iCh) {
-    Double_t mult = esd->GetVZEROEqMultiplicity(iCh);
-    multV0CEq += mult;
+  if (esd) { // only for ESD?
+    for(Int_t iCh = 4; iCh < 7; ++iCh) {
+      Double_t mult = esd->GetVZEROEqMultiplicity(iCh);
+      multV0AEq += mult;
+    }
+    for(Int_t iCh = 0; iCh < 3; ++iCh) {
+      Double_t mult = esd->GetVZEROEqMultiplicity(iCh);
+      multV0CEq += mult;
+    }
   }
-
   Bool_t kT0BB = kFALSE;    
   if (esd) {
     // ***** T0 info    
index b298c446cf12fe9cde33b37f3ee235ebb7861b1b..5b92603e2ee4a957f28d3608f6b32943594a90ff 100644 (file)
@@ -314,7 +314,7 @@ class AliCentralitySelectionTask : public AliAnalysisTaskSE {
   TH1F *fHOutVertex ;           //control histogram for vertex SPD
   TH1F *fHOutVertexT0 ;         //control histogram for vertex T0
 
-  ClassDef(AliCentralitySelectionTask, 29); 
+  ClassDef(AliCentralitySelectionTask, 30); 
 };
 
 #endif
index eb5d0c0fe43baa773132674a1ed8d4dbe18f91e0..ded255871637371a0865decae9d6db4c3647dd2a 100644 (file)
@@ -303,14 +303,14 @@ void AliUnfolding::SetStaticVariables(TH2* correlation, TH1* measured, TH1* effi
     if (sum <= 0)
       continue;
     Float_t maxValue = 0;
-    Int_t maxBin = -1;
+    //    Int_t maxBin = -1;
     for (Int_t j=1; j<=correlation->GetNbinsY(); ++j)
     {
       // find most probably value
       if (maxValue < correlation->GetBinContent(i, j))
       {
         maxValue = correlation->GetBinContent(i, j);
-        maxBin = j;
+       //        maxBin = j;
       }
 
       // npart sum to 1
@@ -1339,12 +1339,8 @@ void AliUnfolding::DrawResults(TH2* correlation, TH1* efficiency, TH1* measured,
   {
     params[i] = initialConditions->GetBinContent(i+1) * efficiency->GetBinContent(i+1);
 
-    Bool_t fix = kFALSE;
     if (params[i] < 0)
-    {
-      fix = kTRUE;
       params[i] = -params[i];
-    }
     params[i]=TMath::Sqrt(params[i]);
   } 
 
index 5ae72bfe1ba13432e327bf13c7653c61dc98ccde..05b4cf804b6a5345dde016fa500d802e64e11f5a 100644 (file)
@@ -309,6 +309,9 @@ void AliPHOSTenderSupply::ProcessEvent()
       cluPHOS.EvalAll(logWeight,vertex);         // recalculate the cluster parameters
       cluPHOS.SetE(CorrectNonlinearity(cluPHOS.E()));// Users's nonlinearity
 
+      Double_t ecore=CoreEnergy(&cluPHOS) ; 
+      ecore=CorrectNonlinearity(ecore) ;
+      
       //Correct Misalignment
 //      CorrectPHOSMisalignment(global,mod) ;
 //      position[0]=global.X() ;
@@ -324,7 +327,9 @@ void AliPHOSTenderSupply::ProcessEvent()
       Float_t  xyz[3];
       cluPHOS.GetPosition(xyz);
       clu->SetPosition(xyz);                       //rec.point position in MARS
-      clu->SetE(cluPHOS.E());                           //total or core particle energy
+      clu->SetE(cluPHOS.E());                      //total particle energy
+      clu->SetMCEnergyFraction(ecore);                            //core particle energy
+      
       //    clu->SetDispersion(cluPHOS.GetDispersion());  //cluster dispersion
       //    ec->SetPID(rp->GetPID()) ;            //array of particle identification
       clu->SetM02(cluPHOS.GetM02()) ;               //second moment M2x
@@ -342,7 +347,10 @@ void AliPHOSTenderSupply::ProcessEvent()
      
       clu->SetEmcCpvDistance(r);    
       clu->SetChi2(TestLambda(clu->E(),clu->GetM20(),clu->GetM02()));                     //not yet implemented
-      clu->SetTOF(EvalTOF(&cluPHOS,cells));       
+      Double_t tof=EvalTOF(&cluPHOS,cells); 
+      if(TMath::Abs(tof-clu->GetTOF())>100.e-9) //something wrong in cell TOF!
+       tof=clu->GetTOF() ;
+      clu->SetTOF(tof);       
       Double_t minDist=clu->GetDistanceToBadChannel() ;//Already calculated
       DistanceToBadChannel(mod,&locPos,minDist);
       clu->SetDistanceToBadChannel(minDist) ;
@@ -378,6 +386,10 @@ void AliPHOSTenderSupply::ProcessEvent()
       cluPHOS.EvalAll(logWeight,vertex);         // recalculate the cluster parameters
       cluPHOS.SetE(CorrectNonlinearity(cluPHOS.E()));// Users's nonlinearity
 
+      Double_t ecore=CoreEnergy(&cluPHOS) ; 
+      ecore=CorrectNonlinearity(ecore) ;
+
+      
       //Correct Misalignment
 //      cluPHOS.GetPosition(position);
 //      global.SetXYZ(position[0],position[1],position[2]);
@@ -387,7 +399,8 @@ void AliPHOSTenderSupply::ProcessEvent()
 //      position[2]=global.Z() ;
 
       clu->SetPosition(position);                       //rec.point position in MARS
-      clu->SetE(cluPHOS.E());                           //total or core particle energy
+      clu->SetE(cluPHOS.E());                           //total particle energy
+      clu->SetMCEnergyFraction(ecore);                  //core particle energy
       clu->SetDispersion(cluPHOS.GetDispersion());  //cluster dispersion
       //    ec->SetPID(rp->GetPID()) ;            //array of particle identification
       clu->SetM02(cluPHOS.GetM02()) ;               //second moment M2x
@@ -415,7 +428,10 @@ void AliPHOSTenderSupply::ProcessEvent()
       clu->SetEmcCpvDistance(r); //Distance in sigmas
      
       clu->SetChi2(TestLambda(clu->E(),clu->GetM20(),clu->GetM02()));                     //not yet implemented
-      clu->SetTOF(EvalTOF(&cluPHOS,cells));       
+      Double_t tof=EvalTOF(&cluPHOS,cells); 
+      if(TMath::Abs(tof-clu->GetTOF())>100.e-9) //something wrong in cell TOF!
+       tof=clu->GetTOF() ;
+      clu->SetTOF(tof);       
       Double_t minDist=clu->GetDistanceToBadChannel() ;//Already calculated
       DistanceToBadChannel(mod,&locPos,minDist);
       clu->SetDistanceToBadChannel(minDist) ;
@@ -748,6 +764,51 @@ void AliPHOSTenderSupply::EvalLambdas(AliVCluster * clu, Double_t &m02, Double_t
   }
 
 }
+//____________________________________________________________________________
+Double_t  AliPHOSTenderSupply::CoreEnergy(AliVCluster * clu){  
+  //calculate energy of the cluster in the circle with radius distanceCut around the maximum
+  
+  //Can not use already calculated coordinates?
+  //They have incidence correction...
+  const Double_t distanceCut =3.5 ;
+  const Double_t logWeight=4.5 ;
+  
+  Double32_t * elist = clu->GetCellsAmplitudeFraction() ;  
+// Calculates the center of gravity in the local PHOS-module coordinates
+  Float_t wtot = 0;
+  Double_t xc[100]={0} ;
+  Double_t zc[100]={0} ;
+  Double_t x = 0 ;
+  Double_t z = 0 ;
+  Int_t mulDigit=TMath::Min(100,clu->GetNCells()) ;
+  for(Int_t iDigit=0; iDigit<mulDigit; iDigit++) {
+    Int_t relid[4] ;
+    Float_t xi ;
+    Float_t zi ;
+    fPHOSGeo->AbsToRelNumbering(clu->GetCellAbsId(iDigit), relid) ;
+    fPHOSGeo->RelPosInModule(relid, xi, zi);
+    xc[iDigit]=xi ;
+    zc[iDigit]=zi ;
+    if (clu->E()>0 && elist[iDigit]>0) {
+      Float_t w = TMath::Max( 0., logWeight + TMath::Log( elist[iDigit] / clu->E() ) ) ;
+      x    += xc[iDigit] * w ;
+      z    += zc[iDigit] * w ;
+      wtot += w ;
+    }
+  }
+  if (wtot>0) {
+    x /= wtot ;
+    z /= wtot ;
+  }
+  Double_t coreE=0. ;
+  for(Int_t iDigit=0; iDigit < mulDigit; iDigit++) {
+    Double_t distance = TMath::Sqrt((xc[iDigit]-x)*(xc[iDigit]-x)+(zc[iDigit]-z)*(zc[iDigit]-z)) ;
+    if(distance < distanceCut)
+      coreE += elist[iDigit] ;
+  }
+  //Apply non-linearity correction
+  return coreE ;
+}
 //________________________________________________________________________
 Double_t AliPHOSTenderSupply::EvalTOF(AliVCluster * clu,AliVCaloCells * cells){ 
   //Evaluate TOF of the cluster after re-calibration
@@ -771,7 +832,6 @@ Double_t AliPHOSTenderSupply::EvalTOF(AliVCluster * clu,AliVCaloCells * cells){
       eMax=elist[iDigit] ;
     }
   }
-
   
    //Try to improve accuracy 
   //Do not account time of soft cells:
index 7c5460a9ceb1e6f3c49e1355ba9322708d50377c..fe9a1c80622057c7af489604dfb1f6f2cadccb71 100644 (file)
@@ -60,6 +60,7 @@ protected:
   Bool_t IsGoodChannel(Int_t mod, Int_t ix, Int_t iz) ;
   void   CorrectPHOSMisalignment(TVector3 & globalPos, Int_t module);
   void   EvalLambdas(AliVCluster * clu, Double_t &m02, Double_t &m20) ;
+  Double_t CoreEnergy(AliVCluster * clu) ;  
   Double_t EvalTOF(AliVCluster * clu,AliVCaloCells * cells); 
   Double_t CalibrateTOF(Double_t tof, Int_t absId, Bool_t isHG); 
   void DistanceToBadChannel(Int_t mod, TVector3 * locPos, Double_t &minDist) ;
diff --git a/ANALYSIS/macros/train/AddMCGenPythia8.C b/ANALYSIS/macros/train/AddMCGenPythia8.C
new file mode 100644 (file)
index 0000000..efabf57
--- /dev/null
@@ -0,0 +1,46 @@
+AliGenerator* AddMCGenPythia8(Float_t e_cms = 2760., Bool_t kCR = kTRUE) 
+{
+  // Add Pythia 8 generator: 
+  //    - Color reconnection = ON/OFF
+
+  gSystem->Load("liblhapdf.so");
+  AliGenerator *genP = NULL;
+  genP = CreatePythia8Gen(e_cms, kCR);
+  
+  return genP;
+}
+
+AliGenerator* CreatePythia8Gen(Float_t e_cms, Bool_t kCR) {
+    
+   gSystem->Load("libpythia6.so");
+   gSystem->Load("libEGPythia6.so");
+   gSystem->Load("libAliPythia6.so");
+   gSystem->Load("libpythia8.so");
+   gSystem->Load("libAliPythia8.so");
+   gSystem->Setenv("PYTHIA8DATA", gSystem->ExpandPathName("$ALICE_ROOT/PYTHIA8/pythia8175/xmldoc"));
+   gSystem->Setenv("LHAPDF",      gSystem->ExpandPathName("$ALICE_ROOT/LHAPDF"));
+   gSystem->Setenv("LHAPATH",     gSystem->ExpandPathName("$ALICE_ROOT/LHAPDF/PDFsets"));
+
+
+  AliGenPythiaPlus* gener = new AliGenPythiaPlus(AliPythia8::Instance());
+
+  // set process (MB)
+  gener->SetProcess(kPyMbDefault);
+  
+  //   Centre of mass energy 
+  gener->SetEnergyCMS(e_cms); // in GeV
+
+  // Event list
+  gener->SetEventListRange(-1, 2);
+
+  // color reconnection
+  (AliPythia8::Instance())->ReadString("Tune:pp = 5");//CR
+
+  if(kCR)             
+    (AliPythia8::Instance())->ReadString("BeamRemnants:reconnectColours = on");
+  else
+    (AliPythia8::Instance())->ReadString("BeamRemnants:reconnectColours = off");
+  
+  return gener;
+}
index eddf81a017e1036ab140c829558183f5c09e1389..d0307e613e8092aee3fdc8ade6fc16bdfd2862dc 100644 (file)
@@ -323,7 +323,7 @@ set(AEXT a)
 set(LIBPATH ${CMAKE_BINARY_DIR}/lib/tgt_${ALICE_TARGET})
 set(BINPATH ${CMAKE_BINARY_DIR}/bin/tgt_${ALICE_TARGET})
 set(EXPORTDIR ${ALICE_ROOT}/include)
-set(BINLIBDIRS -L${ALICE_ROOT}/${LIBPATH})
+#set(BINLIBDIRS -L${ALICE_ROOT}/${LIBPATH})
 set(RAWDIRO ${CMAKE_BINARY_DIR}/RAW)
 set(ALIMDCSPECFILE ${RAWDIRO}/alimdc.spec)
 set(RAWDatabaseALIB ${LIBPATH}/libRAWDatabase.${AEXT})
index 087e72048f28fce81c89078dd129a4fa619ab395..52f4a15d7861667e947bcd4cba7d38403815deff 100644 (file)
@@ -545,8 +545,8 @@ void AliCFUnfolding::FillDeltaUnfoldedProfile() {
   //  mean_{n+1} = (n*mean_n + value_{n+1}) / (n+1)
   // sigma_{n+1} = sqrt { 1/(n+1) * [ n*sigma_n^2 + (n^2+n)*(mean_{n+1}-mean_n)^2 ] }    (can this be optimized?)
 
-  for (Long_t iBin=0; iBin<fUnfolded->GetNbins(); iBin++) {
-    Double_t deltaInBin   = fUnfoldedFinal->GetBinContent(iBin,fCoordinatesN_M) - fUnfolded->GetBinContent(iBin);
+  for (Long_t iBin=0; iBin<fUnfoldedFinal->GetNbins(); iBin++) {
+    Double_t deltaInBin   = fUnfoldedFinal->GetBinContent(iBin,fCoordinatesN_M) - fUnfolded->GetBinContent(fCoordinatesN_M);
     Double_t entriesInBin = fDeltaUnfoldedN->GetBinContent(fCoordinatesN_M);
     //AliDebug(2,Form("%e %e ==> delta = %e\n",fUnfoldedFinal->GetBinContent(iBin,fCoordinatesN_M),fUnfolded->GetBinContent(iBin),deltaInBin));
 
diff --git a/EVE/alice-macros/geom_mft.C b/EVE/alice-macros/geom_mft.C
new file mode 100644 (file)
index 0000000..477e574
--- /dev/null
@@ -0,0 +1,42 @@
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+* Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+* See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for          *
+* full copyright notice.                                                 *
+**************************************************************************/
+
+#if !defined(__CINT__) || defined(__MAKECINT__)
+#include <TGeoManager.h>
+#include <TGeoNode.h>
+#include <TEveManager.h>
+#include <TEveGeoNode.h>
+
+#include <AliEveEventManager.h>
+#endif
+
+void geom_mft()
+
+{
+  //  AliEveEventManager::AssertGeometry();
+
+  gGeoManager = gEve->GetGeometry("geometry.root");
+
+  TEveElementList* list = new TEveElementList("MFT");
+  gEve->AddGlobalElement(list);
+  TGeoNode *node1 = gGeoManager->GetTopVolume()->FindNode("MFT_0");
+  if (!node1) {
+    Warning("geom_mft()", "Node MFT_0 not found !");
+    return;
+  }
+  
+  TEveGeoTopNode* re1 = new TEveGeoTopNode(gGeoManager,node1);
+  re1->UseNodeTrans();
+  gEve->AddGlobalElement(re1,list);
+  
+  gEve->Redraw3D();
+  
+  Info("geom_mft.C", "Done");
+}
index 2d73011794d5a780b798d021222ff01762e5d137..bb6f8d36d6ab4c3184ab7d0864513b7eff1a7453 100644 (file)
@@ -61,7 +61,7 @@ AliGenEMCocktail::AliGenEMCocktail()
   fCentrality(0),
   fV2Systematic(0),
   fForceConv(kFALSE),
-  fHeaviestParticle(kGenJpsi)
+  fSelectedParticles(kGenHadrons)
 {
   // Constructor
 
@@ -97,7 +97,7 @@ void AliGenEMCocktail::CreateCocktail()
 
   // Create and add electron sources to the generator
   // pizero
-  if(fHeaviestParticle<kGenPizero)return;
+  if(fSelectedParticles&kGenPizero){
   AliGenParam *genpizero=0;
   Char_t namePizero[10];    
   snprintf(namePizero,10,"Pizero");    
@@ -106,13 +106,14 @@ void AliGenEMCocktail::CreateCocktail()
   AddSource2Generator(namePizero,genpizero);
   TF1 *fPtPizero = genpizero->GetPt();
 #if ROOT_VERSION_CODE >= ROOT_VERSION(5,99,0)
-  fYieldArray[kGenPizero] = fPtPizero->Integral(fPtMin,fPtMax,1.e-6);
+    fYieldArray[kPizero] = fPtPizero->Integral(fPtMin,fPtMax,1.e-6);
 #else
-  fYieldArray[kGenPizero] = fPtPizero->Integral(fPtMin,fPtMax,(Double_t *)0,1.e-6);
+    fYieldArray[kPizero] = fPtPizero->Integral(fPtMin,fPtMax,(Double_t *)0,1.e-6);
 #endif
+  }
 
   // eta  
-  if(fHeaviestParticle<kGenEta)return;
+  if(fSelectedParticles&kGenEta){
   AliGenParam *geneta=0;
   Char_t nameEta[10];    
   snprintf(nameEta,10,"Eta");    
@@ -121,13 +122,14 @@ void AliGenEMCocktail::CreateCocktail()
   AddSource2Generator(nameEta,geneta);
   TF1 *fPtEta = geneta->GetPt();
 #if ROOT_VERSION_CODE >= ROOT_VERSION(5,99,0)
-  fYieldArray[kGenEta] = fPtEta->Integral(fPtMin,fPtMax,1.e-6);
+    fYieldArray[kEta] = fPtEta->Integral(fPtMin,fPtMax,1.e-6);
 #else
-  fYieldArray[kGenEta] = fPtEta->Integral(fPtMin,fPtMax,(Double_t *)0,1.e-6);
+    fYieldArray[kEta] = fPtEta->Integral(fPtMin,fPtMax,(Double_t *)0,1.e-6);
 #endif
+  }
 
   // rho  
-  if(fHeaviestParticle<kGenRho)return;
+  if(fSelectedParticles&kGenRho){
   AliGenParam *genrho=0;
   Char_t nameRho[10];    
   snprintf(nameRho,10,"Rho");    
@@ -136,13 +138,14 @@ void AliGenEMCocktail::CreateCocktail()
   AddSource2Generator(nameRho,genrho);
   TF1 *fPtRho = genrho->GetPt();
 #if ROOT_VERSION_CODE >= ROOT_VERSION(5,99,0)
-  fYieldArray[kGenRho] = fPtRho->Integral(fPtMin,fPtMax,1.e-6);
+    fYieldArray[kRho] = fPtRho->Integral(fPtMin,fPtMax,1.e-6);
 #else
-  fYieldArray[kGenRho] = fPtRho->Integral(fPtMin,fPtMax,(Double_t *)0,1.e-6);
+    fYieldArray[kRho] = fPtRho->Integral(fPtMin,fPtMax,(Double_t *)0,1.e-6);
 #endif
+  }
   
   // omega
-  if(fHeaviestParticle<kGenOmega)return;
+  if(fSelectedParticles&kGenOmega){
   AliGenParam *genomega=0;
   Char_t nameOmega[10];    
   snprintf(nameOmega,10,"Omega");    
@@ -151,13 +154,14 @@ void AliGenEMCocktail::CreateCocktail()
   AddSource2Generator(nameOmega,genomega);
   TF1 *fPtOmega = genomega->GetPt();
 #if ROOT_VERSION_CODE >= ROOT_VERSION(5,99,0)
-  fYieldArray[kGenOmega] = fPtOmega->Integral(fPtMin,fPtMax,1.e-6);
+    fYieldArray[kOmega] = fPtOmega->Integral(fPtMin,fPtMax,1.e-6);
 #else
-  fYieldArray[kGenOmega] = fPtOmega->Integral(fPtMin,fPtMax,(Double_t *)0,1.e-6);
+    fYieldArray[kOmega] = fPtOmega->Integral(fPtMin,fPtMax,(Double_t *)0,1.e-6);
 #endif
+  }
 
   // etaprime
-  if(fHeaviestParticle<kGenEtaprime)return;
+  if(fSelectedParticles&kGenEtaprime){
   AliGenParam *genetaprime=0;
   Char_t nameEtaprime[10];    
   snprintf(nameEtaprime,10,"Etaprime");    
@@ -166,13 +170,14 @@ void AliGenEMCocktail::CreateCocktail()
   AddSource2Generator(nameEtaprime,genetaprime);
   TF1 *fPtEtaprime = genetaprime->GetPt();
 #if ROOT_VERSION_CODE >= ROOT_VERSION(5,99,0)
-  fYieldArray[kGenEtaprime] = fPtEtaprime->Integral(fPtMin,fPtMax,1.e-6);
+    fYieldArray[kEtaprime] = fPtEtaprime->Integral(fPtMin,fPtMax,1.e-6);
 #else
-  fYieldArray[kGenEtaprime] = fPtEtaprime->Integral(fPtMin,fPtMax,(Double_t *)0,1.e-6);
+    fYieldArray[kEtaprime] = fPtEtaprime->Integral(fPtMin,fPtMax,(Double_t *)0,1.e-6);
 #endif
+  }
 
   // phi  
-  if(fHeaviestParticle<kGenPhi)return;
+  if(fSelectedParticles&kGenPhi){
   AliGenParam *genphi=0;
   Char_t namePhi[10];    
   snprintf(namePhi,10,"Phi");    
@@ -181,13 +186,14 @@ void AliGenEMCocktail::CreateCocktail()
   AddSource2Generator(namePhi,genphi);
   TF1 *fPtPhi = genphi->GetPt();
 #if ROOT_VERSION_CODE >= ROOT_VERSION(5,99,0)
-  fYieldArray[kGenPhi] = fPtPhi->Integral(fPtMin,fPtMax,1.e-6);
+    fYieldArray[kPhi] = fPtPhi->Integral(fPtMin,fPtMax,1.e-6);
 #else
-  fYieldArray[kGenPhi] = fPtPhi->Integral(fPtMin,fPtMax,(Double_t *)0,1.e-6);
+    fYieldArray[kPhi] = fPtPhi->Integral(fPtMin,fPtMax,(Double_t *)0,1.e-6);
 #endif
+  }
 
   // jpsi  
-  if(fHeaviestParticle<kGenJpsi)return;
+  if(fSelectedParticles&kGenJpsi){
   AliGenParam *genjpsi=0;
   Char_t nameJpsi[10];    
   snprintf(nameJpsi,10,"Jpsi");    
@@ -196,76 +202,44 @@ void AliGenEMCocktail::CreateCocktail()
   AddSource2Generator(nameJpsi,genjpsi);
   TF1 *fPtJpsi = genjpsi->GetPt();
 #if ROOT_VERSION_CODE >= ROOT_VERSION(5,99,0)
-  fYieldArray[kGenJpsi] = fPtJpsi->Integral(fPtMin,fPtMax,1.e-6);
+    fYieldArray[kJpsi] = fPtJpsi->Integral(fPtMin,fPtMax,1.e-6);
 #else
-  fYieldArray[kGenJpsi] = fPtJpsi->Integral(fPtMin,fPtMax,(Double_t *)0,1.e-6);
-#endif
-
-  // prompt gamma
-  if(fDecayMode==kGammaEM){
-    if(fHeaviestParticle<kGenPromptRealGamma)return;
-    TDatabasePDG::Instance()->AddParticle("PromptRealGamma","PromptRealGamma",0,true,0,0,"GaugeBoson",221000);
-    //gMC->DefineParticle(221000, "PromptGamma", kPTGamma, 0, 0, 0,"Gamma", 0.0, 0, 0, 0, 0, 0, 0, 0, 0, kFALSE);
-    AliGenParam *genPromptRealG=0;
-    Char_t namePromptRealG[10];    
-    snprintf(namePromptRealG,10,"PromptRealGamma");    
-    genPromptRealG = new AliGenParam(fNPart*0.5, new AliGenEMlib(), AliGenEMlib::kPromptRealGamma, "DUMMY");
-    genPromptRealG->SetYRange(fYMin, fYMax);
-    AddSource2Generator(namePromptRealG,genPromptRealG);
-    TF1 *fPtPromptRealG = genPromptRealG->GetPt();
-#if ROOT_VERSION_CODE >= ROOT_VERSION(5,99,0)
-    fYieldArray[kGenPromptRealGamma] = fPtPromptRealG->Integral(fPtMin,fPtMax,1.e-6);
-#else
-    fYieldArray[kGenPromptRealGamma] = fPtPromptRealG->Integral(fPtMin,fPtMax,(Double_t *)0,1.e-6);
-#endif
-
-    if(fHeaviestParticle<kGenThermRealGamma)return;
-    TDatabasePDG::Instance()->AddParticle("ThermRealGamma","ThermRealGamma",0,true,0,0,"GaugeBoson",222000);
-    //gMC->DefineParticle(221000, "ThermGamma", kPTGamma, 0, 0, 0,"Gamma", 0.0, 0, 0, 0, 0, 0, 0, 0, 0, kFALSE);
-    AliGenParam *genThermRealG=0;
-    Char_t nameThermRealG[10];    
-    snprintf(nameThermRealG,10,"ThermRealGamma");    
-    genThermRealG = new AliGenParam(fNPart*0.5, new AliGenEMlib(), AliGenEMlib::kThermRealGamma, "DUMMY");
-    genThermRealG->SetYRange(fYMin, fYMax);
-    AddSource2Generator(nameThermRealG,genThermRealG);
-    TF1 *fPtThermRealG = genThermRealG->GetPt();
-#if ROOT_VERSION_CODE >= ROOT_VERSION(5,99,0)
-    fYieldArray[kGenThermRealGamma] = fPtThermRealG->Integral(fPtMin,fPtMax,1.e-6);
-#else
-    fYieldArray[kGenThermRealGamma] = fPtThermRealG->Integral(fPtMin,fPtMax,(Double_t *)0,1.e-6);
+    fYieldArray[kJpsi] = fPtJpsi->Integral(fPtMin,fPtMax,(Double_t *)0,1.e-6);
 #endif
+  }
 
-    if(fHeaviestParticle<kGenPromptVirtGamma)return;
-    TDatabasePDG::Instance()->AddParticle("PromptVirtGamma","PromptVirtGamma",0,true,0,0,"GaugeBoson",223000);
-    AliGenParam *genPromptVirtG=0;
-    Char_t namePromptVirtG[10];    
-    snprintf(namePromptVirtG,10,"PromptVirtGamma");    
-    genPromptVirtG = new AliGenParam(fNPart*0.5, new AliGenEMlib(), AliGenEMlib::kPromptVirtGamma, "DUMMY");
-    genPromptVirtG->SetYRange(fYMin, fYMax);
-    AddSource2Generator(namePromptVirtG,genPromptVirtG);
-    TF1 *fPtPromptVirtG = genPromptVirtG->GetPt();
+  // direct gamma
+  if(fDecayMode!=kGammaEM) return;
+  if(fSelectedParticles&kGenDirectRealGamma){
+    AliGenParam *genDirectRealG=0;
+    Char_t nameDirectRealG[10];    
+    snprintf(nameDirectRealG,10,"DirectRealGamma");    
+    genDirectRealG = new AliGenParam(fNPart, new AliGenEMlib(), AliGenEMlib::kDirectRealGamma, "DUMMY");
+    genDirectRealG->SetYRange(fYMin, fYMax);
+    AddSource2Generator(nameDirectRealG,genDirectRealG);
+    TF1 *fPtDirectRealG = genDirectRealG->GetPt();
 #if ROOT_VERSION_CODE >= ROOT_VERSION(5,99,0)
-    fYieldArray[kGenPromptVirtGamma] = fPtPromptVirtG->Integral(fPtMin,fPtMax,1.e-6);
+    fYieldArray[kDirectRealGamma] = fPtDirectRealG->Integral(fPtMin,fPtMax,1.e-6);
 #else
-    fYieldArray[kGenPromptVirtGamma] = fPtPromptVirtG->Integral(fPtMin,fPtMax,(Double_t *)0,1.e-6);
+    fYieldArray[kDirectRealGamma] = fPtDirectRealG->Integral(fPtMin,fPtMax,(Double_t *)0,1.e-6);
 #endif
+  }
 
-    if(fHeaviestParticle<kGenThermVirtGamma)return;
-    TDatabasePDG::Instance()->AddParticle("ThermVirtGamma","ThermVirtGamma",0,true,0,0,"GaugeBoson",224000);
-    AliGenParam *genThermVirtG=0;
-    Char_t nameThermVirtG[10];    
-    snprintf(nameThermVirtG,10,"ThermVirtGamma");    
-    genThermVirtG = new AliGenParam(fNPart*0.5, new AliGenEMlib(), AliGenEMlib::kThermVirtGamma, "DUMMY");
-    genThermVirtG->SetYRange(fYMin, fYMax);
-    AddSource2Generator(nameThermVirtG,genThermVirtG);
-    TF1 *fPtThermVirtG = genThermVirtG->GetPt();
+  if(fSelectedParticles&kGenDirectVirtGamma){
+    TDatabasePDG::Instance()->AddParticle("DirectVirtGamma","DirectVirtGamma",0,true,0,0,"GaugeBoson",220000);
+    AliGenParam *genDirectVirtG=0;
+    Char_t nameDirectVirtG[10];    
+    snprintf(nameDirectVirtG,10,"DirectVirtGamma");    
+    genDirectVirtG = new AliGenParam(fNPart/0.775, new AliGenEMlib(), AliGenEMlib::kDirectVirtGamma, "DUMMY");
+    genDirectVirtG->SetYRange(fYMin/0.775, fYMax/0.775);
+    AddSource2Generator(nameDirectVirtG,genDirectVirtG);
+    TF1 *fPtDirectVirtG = genDirectVirtG->GetPt();
 #if ROOT_VERSION_CODE >= ROOT_VERSION(5,99,0)
-    fYieldArray[kGenThermVirtGamma] = fPtThermVirtG->Integral(fPtMin,fPtMax,1.e-6);
+    fYieldArray[kDirectVirtGamma] = fPtDirectVirtG->Integral(fPtMin,fPtMax,1.e-6);
 #else
-    fYieldArray[kGenThermVirtGamma] = fPtThermVirtG->Integral(fPtMin,fPtMax,(Double_t *)0,1.e-6);
+    fYieldArray[kDirectVirtGamma] = fPtDirectVirtG->Integral(fPtMin,fPtMax,(Double_t *)0,1.e-6);
 #endif
   }
-  
 }
 
 //-------------------------------------------------------------------
@@ -362,44 +336,37 @@ void AliGenEMCocktail::Generate()
 
     switch (pdgMother){
     case 111:
-      dNdy = fYieldArray[kGenPizero];
+      dNdy = fYieldArray[kPizero];
       break;
     case 221:
-      dNdy = fYieldArray[kGenEta];
+      dNdy = fYieldArray[kEta];
       break;
     case 113:
-      dNdy = fYieldArray[kGenRho];
+      dNdy = fYieldArray[kRho];
       break;
     case 223:
-      dNdy = fYieldArray[kGenOmega];
+      dNdy = fYieldArray[kOmega];
       break;
     case 331:
-      dNdy = fYieldArray[kGenEtaprime];
+      dNdy = fYieldArray[kEtaprime];
       break;
     case 333:
-      dNdy = fYieldArray[kGenPhi];
+      dNdy = fYieldArray[kPhi];
       break;
     case 443:
-      dNdy = fYieldArray[kGenJpsi];
+      dNdy = fYieldArray[kJpsi];
+      break;
+    case 22:
+      dNdy = fYieldArray[kDirectRealGamma];
       break;
+    case 220000:
+      dNdy = fYieldArray[kDirectVirtGamma];
+      break;
+      
     default:
       dNdy = 0.;
     }
 
-    switch (pdgMother){
-    case 221000:
-      dNdy = fYieldArray[kGenPromptRealGamma];
-      break;
-    case 223000:
-      dNdy = fYieldArray[kGenPromptVirtGamma];
-      break;
-    case 222000:
-      dNdy = fYieldArray[kGenThermRealGamma];
-      break;      
-    case 224000:
-      dNdy = fYieldArray[kGenThermVirtGamma];
-      break;   
-    }
     weight = dNdy*part->GetWeight();
     part->SetWeight(weight);
   }    
index 96ed2497244226586eb2947f5de3b1da3db2fe25..89b7a50554e7b723c2c287307c5c01354ece6dd7 100644 (file)
@@ -23,7 +23,8 @@ class AliGenEMCocktail : public AliGenCocktail
 public:
 
     AliGenEMCocktail();
-  enum GeneratorCode { kGenPizero=0, kGenEta, kGenRho, kGenOmega, kGenEtaprime, kGenPhi, kGenJpsi, kGenPromptRealGamma, kGenThermRealGamma, kGenPromptVirtGamma, kGenThermVirtGamma, kGENs };
+  enum GeneratorCode { kPizero=0, kEta, kRho, kOmega, kEtaprime, kPhi, kJpsi, kDirectRealGamma, kDirectVirtGamma, kGENs };
+  enum SelectPartice { kGenPizero=0x001, kGenEta=0x002, kGenRho=0x004, kGenOmega=0x008, kGenEtaprime=0x010, kGenPhi=0x020, kGenJpsi=0x040, kGenDirectRealGamma=0x100, kGenDirectVirtGamma=0x200, kGenHadrons=0x7f, kGenGammas=0x300 };
 
     virtual ~AliGenEMCocktail();    
     virtual void Init();
@@ -39,7 +40,7 @@ public:
   void    SetCentrality(Int_t cent){ fCentrality = cent; }
   void    SetV2Systematic(Int_t v2sys){ fV2Systematic = v2sys; }
   void    SetForceGammaConversion(Bool_t force=kTRUE){ fForceConv=force; }
-  void    SetHeaviestParticle(Int_t part){ fHeaviestParticle=part; }
+  void    SelectMotherParticles(Int_t part){ fSelectedParticles=part; }
     
 private:
     AliGenEMCocktail(const AliGenEMCocktail &cocktail); 
@@ -59,7 +60,7 @@ private:
   Int_t fV2Systematic; //selected systematic error for v2 parameters
 
   Bool_t fForceConv; //select whether you want to force all gammas to convert imidediately
-  Int_t fHeaviestParticle; //select up to which particle to simulate
+  Int_t fSelectedParticles; //which particles to simulate
 
     ClassDef(AliGenEMCocktail,1)  //  cocktail for EM physics
 };
index 9c80a67a776721c3c13996d0d7e219583bbdea75..26305cffcaf394d07fb8f3bde6833d4ae972554d 100644 (file)
@@ -40,25 +40,25 @@ Int_t AliGenEMlib::fgSelectedPtParam=AliGenEMlib::kPizero7TeVpp;
 Int_t AliGenEMlib::fgSelectedCentrality=AliGenEMlib::kpp;
 Int_t AliGenEMlib::fgSelectedV2Systematic=AliGenEMlib::kNoV2Sys;
 
-Double_t AliGenEMlib::CrossOverLc(const double a, const double b, const double x){
+Double_t AliGenEMlib::CrossOverLc(double a, double b, double x){
   if(x<b-a/2) return 1.0;
   else if(x>b+a/2) return 0.0;
   else return cos(((x-b)/a+0.5)*TMath::Pi())/2+0.5;
 }
-Double_t AliGenEMlib::CrossOverRc(const double a, const double b, const double x){
+Double_t AliGenEMlib::CrossOverRc(double a, double b, double x){
   return 1-CrossOverLc(a,b,x);
 }
 
 const Double_t AliGenEMlib::fgkV2param[16][15] = {
-  // charged pion                                                                                                                        cent, based on
+  // charged pion                                                                                                                        cent, based on: https://twiki.cern.ch/twiki/bin/viewauth/ALICE/FlowPAGQM2012talkIdentified
   {  0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000, 0.0000000000, 2.0000000000, 0.0000000000, 1.0000000000, 0, 1, 0.0000000000, 1.0000000000 }   // pp no V2
-  ,{ 6.551541e-02, 1.438274e+00, 4.626379e-02, 2.512477e+00, 1.371824e+00, 2.964543e-02, 4.630670e+00, 4.228889e+00, 6.037970e-02, 1.425269e-03, 1.144124e+00, 0, 1, 9.154016e-04, 1.288285e+00 }  // 0-5,  Francesco
-  ,{ 1.171360e-01, 1.333046e+00, 4.536752e-02, 3.046448e+00, 3.903714e+00, 4.407124e-02, 9.122534e-01, 4.834519e+00, 1.186237e-01, 2.179274e-03, 8.968478e-01, 0, 1, 1.501201e-03, 9.902785e-01 }  // 5-10, Francesco
-  ,{ 1.748423e-01, 1.285211e+00, 4.219624e-02, 4.019148e+00, 4.255047e+00, 7.956751e-03, 1.184731e-01,-9.211391e+00, 5.768716e-01, 3.127110e-03, 6.808650e-01, 0, 1, 2.786807e-03, 6.159338e-01 }  // 10-20,Francesco
-  ,{ 2.152937e-01, 1.405391e+00, 5.037925e-02, 3.214458e+00, 3.991894e+00, 3.655882e-02, 1.968766e-01,-1.637650e+01, 7.023397e+00, 4.573453e-03, 6.031381e-01, 0, 1, 3.564348e-03, 5.748053e-01 }  // 20-30,Francesco
-  ,{ 2.409800e-01, 1.476557e+00, 5.759362e-02, 3.339713e+00, 3.642386e+00,-1.544366e-02, 1.098611e-01,-1.373154e+01, 1.471955e+00, 5.200180e-03, 6.315474e-01, 0, 1, 3.776112e-03, 6.298605e-01 }  // 30-40,Francesco
-  ,{ 2.495087e-01, 1.543711e+00, 6.217817e-02, 3.517101e+00, 4.558221e+00, 6.021316e-02, 1.486822e-01,-5.769155e+00, 5.576843e-01, 5.348029e-03, 7.255976e-01, 0, 1, 3.531350e-03, 7.661694e-01 }  // 40-50,Francesco
-  ,{ 2.166449e-01, 1.931014e+00, 8.195656e-02, 2.226742e+00, 3.106472e+00, 1.058786e-01, 8.558786e-01, 4.006680e+00, 2.476313e-01, 5.137623e-03, 9.104401e-01, 0, 1, 2.477450e-03, 1.109649e+00 }  // 50-60,Francesco
+  ,{ 6.551541e-02, 1.438274e+00, 4.626379e-02, 2.512477e+00, 1.371824e+00, 2.964543e-02, 4.630670e+00, 4.228889e+00, 6.037970e-02, 1.425269e-03, 1.144124e+00, 0, 1, 9.154016e-04, 1.288285e+00 }  // 0-5
+  ,{ 1.171360e-01, 1.333046e+00, 4.536752e-02, 3.046448e+00, 3.903714e+00, 4.407124e-02, 9.122534e-01, 4.834519e+00, 1.186237e-01, 2.179274e-03, 8.968478e-01, 0, 1, 1.501201e-03, 9.902785e-01 }  // 5-10
+  ,{ 1.748423e-01, 1.285211e+00, 4.219624e-02, 4.019148e+00, 4.255047e+00, 7.956751e-03, 1.184731e-01,-9.211391e+00, 5.768716e-01, 3.127110e-03, 6.808650e-01, 0, 1, 2.786807e-03, 6.159338e-01 }  // 10-20
+  ,{ 2.152937e-01, 1.405391e+00, 5.037925e-02, 3.214458e+00, 3.991894e+00, 3.655882e-02, 1.968766e-01,-1.637650e+01, 7.023397e+00, 4.573453e-03, 6.031381e-01, 0, 1, 3.564348e-03, 5.748053e-01 }  // 20-30
+  ,{ 2.409800e-01, 1.476557e+00, 5.759362e-02, 3.339713e+00, 3.642386e+00,-1.544366e-02, 1.098611e-01,-1.373154e+01, 1.471955e+00, 5.200180e-03, 6.315474e-01, 0, 1, 3.776112e-03, 6.298605e-01 }  // 30-40
+  ,{ 2.495087e-01, 1.543711e+00, 6.217817e-02, 3.517101e+00, 4.558221e+00, 6.021316e-02, 1.486822e-01,-5.769155e+00, 5.576843e-01, 5.348029e-03, 7.255976e-01, 0, 1, 3.531350e-03, 7.661694e-01 }  // 40-50
+  ,{ 2.166449e-01, 1.931014e+00, 8.195656e-02, 2.226742e+00, 3.106472e+00, 1.058786e-01, 8.558786e-01, 4.006680e+00, 2.476313e-01, 5.137623e-03, 9.104401e-01, 0, 1, 2.477450e-03, 1.109649e+00 }  // 50-60
   ,{ 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000, 0.0000000000, 2.0000000000, 0.0000000000, 1.0000000000, 0, 1, 0.0000000000, 1.0000000000 }   // 0-10
   ,{ 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000, 0.0000000000, 2.0000000000, 0.0000000000, 1.0000000000, 0, 1, 0.0000000000, 1.0000000000 }   // 20-40
   ,{ 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000, 0.0000000000, 2.0000000000, 0.0000000000, 1.0000000000, 0, 1, 0.0000000000, 1.0000000000 }   // 40-60
@@ -92,17 +92,17 @@ const Double_t AliGenEMlib::fgkThermPtParam[16][2] = {
   {  0.0000000000, 0.0000000000 } // pp no V2
   ,{ 0.0000000000, 0.0000000000 } // 0-5
   ,{ 0.0000000000, 0.0000000000 } // 5-10
-  ,{ 2.581823e+01, 3.187900e+00 } // 10-20 //from: https://aliceinfo.cern.ch/Notes/node/249
+  ,{ 3.447105e+01, 3.416818e+00 } // 10-20 //based on: https://aliceinfo.cern.ch/Notes/node/249
   ,{ 0.0000000000, 0.0000000000 } // 20-30
   ,{ 0.0000000000, 0.0000000000 } // 30-40
   ,{ 0.0000000000, 0.0000000000 } // 40-50
   ,{ 0.0000000000, 0.0000000000 } // 50-60
-  ,{ 7.177551e+02, 4.946179e+00 } // 0-10  //from: https://aliceinfo.cern.ch/Notes/node/249
-  ,{ 2.328661e+00, 2.635257e+00 } // 20-40 //from: https://twiki.cern.ch/twiki/pub/ALICE/ALICEDirectPhotonSpectrumPaper/directPbPb.pdf
+  ,{ 3.888847e+02, 4.502683e+00 } // 0-10  //based on: https://aliceinfo.cern.ch/Notes/node/249
+  ,{ 1.766210e+00, 2.473812e+00 } // 20-40 //based on: https://twiki.cern.ch/twiki/pub/ALICE/ALICEDirectPhotonSpectrumPaper/directPbPb.pdf
   ,{ 0.0000000000, 0.0000000000 } // 40-60
   ,{ 0.0000000000, 0.0000000000 } // 60-80
-  ,{ 1.919280e+01, 2.946472e+00 } // 0-20  //from: https://twiki.cern.ch/twiki/pub/ALICE/ALICEDirectPhotonSpectrumPaper/directPbPb.pdf
-  ,{ 0.0000000000, 0.0000000000 } // 0-40 
+  ,{ 1.576151e+01, 2.841202e+00 } // 0-20  //based on: https://twiki.cern.ch/twiki/pub/ALICE/ALICEDirectPhotonSpectrumPaper/directPbPb.pdf
+  ,{ 4.263499e+01, 3.249843e+00 } // 0-40  //based on: https://aliceinfo.cern.ch/Figure/node/2866
   ,{ 0.0000000000, 0.0000000000 } // 20-80
   ,{ 0.0000000000, 0.0000000000 } // 40-80
 };
@@ -119,11 +119,10 @@ const Double_t AliGenEMlib::fgkMtFactor[2][8] = {
   //https://aliceinfo.cern.ch/Figure/node/2634
   //https://aliceinfo.cern.ch/Figure/node/2788
   //https://aliceinfo.cern.ch/Figure/node/4403
-  //J/Psi PbPb from Comparison with Julian Books J/Psi -> e+e-, might be contradicting with https://aliceinfo.cern.ch/Figure/node/3457
   //https://aliceinfo.cern.ch/Notes/node/87
   //best guess:
-  {1., 0.48, 1.0, 0.9, 0.4, 0.25, 0.004, 0.}, //pp
-  {1., 0.48, 1.0, 0.9, 0.4, 0.25, 0.0195, 0.}  //PbPb
+  {1., 0.48, 1.0, 0.9, 0.4, 0.25, 0., 0.}, //pp
+  {1., 0.48, 1.0, 0.9, 0.4, 0.25, 0., 0.}  //PbPb
 };
 
 //==========================================================================
@@ -137,13 +136,13 @@ const Double_t AliGenEMlib::fgkMtFactor[2][8] = {
 //                              General functions
 //
 //--------------------------------------------------------------------------
-Double_t AliGenEMlib::PtModifiedHagedornThermal(const Double_t pt,
-                                                const Double_t c,
-                                                const Double_t p0,
-                                                const Double_t p1,
-                                                const Double_t n,
-                                                const Double_t cT,
-                                                const Double_t T)
+Double_t AliGenEMlib::PtModifiedHagedornThermal(Double_t pt,
+                                                Double_t c,
+                                                Double_t p0,
+                                                Double_t p1,
+                                                Double_t n,
+                                                Double_t cT,
+                                                Double_t T)
 {
   // Modified Hagedorn Thermal fit to Picharged for PbPb:
   Double_t invYield;
@@ -154,12 +153,12 @@ Double_t AliGenEMlib::PtModifiedHagedornThermal(const Double_t pt,
 
 
 
-Double_t AliGenEMlib::PtModifiedHagedornExp(const Double_t pt,
-                                           const Double_t c,
-                                           const Double_t p1,
-                                           const Double_t p2,
-                                           const Double_t p0,
-                                           const Double_t n)
+Double_t AliGenEMlib::PtModifiedHagedornExp(Double_t pt,
+                                           Double_t c,
+                                           Double_t p1,
+                                           Double_t p2,
+                                           Double_t p0,
+                                           Double_t n)
 {
   // Modified Hagedorn exponentiel fit to Pizero for PbPb:
   Double_t invYield;
@@ -169,14 +168,14 @@ Double_t AliGenEMlib::PtModifiedHagedornExp(const Double_t pt,
 }
 
 
-Double_t AliGenEMlib::PtModifiedHagedornExp2(const Double_t pt,
-                                             const Double_t c,
-                                             const Double_t a,
-                                             const Double_t b,
-                                             const Double_t p0,
-                                             const Double_t p1,
-                                             const Double_t d,
-                                             const Double_t n)
+Double_t AliGenEMlib::PtModifiedHagedornExp2(Double_t pt,
+                                             Double_t c,
+                                             Double_t a,
+                                             Double_t b,
+                                             Double_t p0,
+                                             Double_t p1,
+                                             Double_t d,
+                                             Double_t n)
 {
   // Modified Hagedorn exponential fit to charged pions for pPb:
   Double_t invYield;
@@ -185,11 +184,11 @@ Double_t AliGenEMlib::PtModifiedHagedornExp2(const Double_t pt,
   return invYield*(2*TMath::Pi()*pt);
 }
 
-Double_t AliGenEMlib::PtTsallis(const Double_t pt,
-                                const Double_t m,
-                                const Double_t c,
-                                const Double_t T,
-                                const Double_t n)
+Double_t AliGenEMlib::PtTsallis(Double_t pt,
+                                Double_t m,
+                                Double_t c,
+                                Double_t T,
+                                Double_t n)
 {
   // Tsallis fit to Pizero for pp:
   Double_t mt;
@@ -211,120 +210,108 @@ Double_t AliGenEMlib::PtExponential(const Double_t *px, const Double_t *c){
 
 // Hagedorn with additional Powerlaw
 Double_t AliGenEMlib::PtModifiedHagedornPowerlaw(const Double_t *px, const Double_t *c){
-  double pt=px[0]+0.0001;
-  Double_t invYield = c[0]*pow(c[1]+pt*c[2],-c[3])*CrossOverLc(c[5],c[4],pt)+CrossOverRc(c[7],c[6],pt)*c[8]*pow(pt,-c[9]);
+  const double &pt=px[0];
+  Double_t invYield = c[0]*pow(c[1]+pt*c[2],-c[3])*CrossOverLc(c[5],c[4],pt)+CrossOverRc(c[7],c[6],pt)*c[8]*pow(pt+0.001,-c[9]); //pt+0.001: prevent powerlaw from exploding for pt->0
   
   return invYield*(2*TMath::Pi()*pt);
 }
 
-Double_t AliGenEMlib::IntegratedKrollWada(Double_t mh){
-  if(mh<0.003) return 0;
-  const double me=0.000511;
-  return 2*log(mh/me/exp(7.0/4.0))/411.0/TMath::Pi();
+// double powerlaw for J/Psi yield
+Double_t AliGenEMlib::PtDoublePowerlaw(const Double_t *px, const Double_t *c){
+  const double &pt=px[0];
+  Double_t yield = c[0]*pt*pow(1+pow(pt*c[1],2),-c[2]);
+  
+  return yield;
+}
+
+// integral over krollwada with S=1^2*(1-mee^2/mh^2)^3 from mee=0 up to mee=mh
+// approximation is perfect for mh>20MeV
+Double_t AliGenEMlib::IntegratedKrollWada(const Double_t *mh, const Double_t *){
+  if(*mh<0.002941) return 0;
+  return 2*log(*mh/0.000511/exp(1.75))/411.11/TMath::Pi();
 }
 
 //--------------------------------------------------------------------------
 //
-//                             PromptRealGamma
+//                             DirectRealGamma
 //
 //--------------------------------------------------------------------------
-Int_t AliGenEMlib::IpPromptRealGamma(TRandom *)
-{
-  return 221000;
-}
-
 Double_t AliGenEMlib::PtPromptRealGamma( const Double_t *px, const Double_t */*dummy*/ )
 {
-  //if(*px<0.001) return 0;
-  const static Double_t promptGammaPtParam[10] = { 7.019259e-02, 6.771695e-01, 8.249346e-01, 5.720419e+00, 1.848869e+01, 2.629075e+01, 1.061126e+01, 3.699205e+01, 5.253572e-02, 5.167275e+00 };
-  //{ 5.449971e-02, 3.843241e-01, 9.469766e-01, 4.993039e+00, 5.342451e+00, 4.457944e+00, 5.555146e+00, 4.458580e+00, 6.035177e-02, 5.102109e+00 };
+  const static Double_t promptGammaPtParam[10] = { 8.715017e-02, 4.439243e-01, 1.011650e+00, 5.193789e+00, 2.194442e+01, 1.062124e+01, 2.469876e+01, 6.052479e-02, 5.611410e-02, 5.169743e+00 };
  
   return PtModifiedHagedornPowerlaw(px,promptGammaPtParam)*GetTAA(fgSelectedCentrality);
 }
 
-Double_t AliGenEMlib::YPromptRealGamma( const Double_t *px, const Double_t */*dummy*/ )
+Double_t AliGenEMlib::PtThermalRealGamma( const Double_t *px, const Double_t */*dummy*/ )
 {
-  return YFlat(*px);
-}
-
-Double_t AliGenEMlib::V2PromptRealGamma( const Double_t */*px*/, const Double_t */*dummy*/ )
-{
-  return 0.0;
+  return PtExponential(px,fgkThermPtParam[fgSelectedCentrality]);
 }
 
-//--------------------------------------------------------------------------
-//
-//                             PromptVirtGamma
-//
-//--------------------------------------------------------------------------
-Int_t AliGenEMlib::IpPromptVirtGamma(TRandom *)
+Double_t AliGenEMlib::PtDirectRealGamma( const Double_t *px, const Double_t */*dummy*/ )
 {
-  return 223000;
+  return PtPromptRealGamma(px,px)+PtThermalRealGamma(px,px);
 }
 
-Double_t AliGenEMlib::PtPromptVirtGamma( const Double_t *px, const Double_t */*dummy*/ )
+Int_t AliGenEMlib::IpDirectRealGamma(TRandom *)
 {
-  return IntegratedKrollWada(*px)*PtPromptRealGamma(px,px);
+  return 22;
 }
 
-Double_t AliGenEMlib::YPromptVirtGamma( const Double_t *px, const Double_t */*dummy*/ )
+Double_t AliGenEMlib::YDirectRealGamma( const Double_t *px, const Double_t */*dummy*/ )
 {
   return YFlat(*px);
 }
 
-Double_t AliGenEMlib::V2PromptVirtGamma( const Double_t */*px*/, const Double_t */*dummy*/ )
+Double_t AliGenEMlib::V2DirectRealGamma( const Double_t *px, const Double_t */*dummy*/ )
 {
-  return 0.0;
+  const static Double_t v2Param[3][15] = {
+    { 1.211795e-01, 9.813671e-01, 0.000000e+00, 3.056960e+00, 2.380183e+00, -7.833212e-02, 5.000000e-01, 3.056960e+00, 1.195000e-01, 1.183293e-02, 1.252249e+00, 0, 1, 4.876263e-03, 1.518526e+00 }  // 00-20, based on: https://aliceinfo.cern.ch/Notes/node/249
+    ,{ 1.619000e-01, 2.185695e+00, 0.000000e+00, 1.637681e+00, 1.000000e+00, -1.226399e-06, 3.092027e+00, 3.064692e+00, 1.619000e-01, 2.264320e-02, 1.028641e+00, 0, 1, 8.172203e-03, 1.271637e+00 } // 20-40
+    ,{ 1.335000e-01, 1.331963e+00, 0.000000e+00, 2.252315e+00, 1.198383e+00, -5.861987e-02, 7.132859e-01, 2.252315e+00, 2.934249e-01, 1.571589e-02, 1.001131e+00, 0, 1, 5.179715e-03, 1.329344e+00 } // 00-40
+  };
+  switch(fgSelectedCentrality) {
+  case k0020: return V2Param(px,v2Param[0]); break;
+  case k2040: return V2Param(px,v2Param[1]); break;
+  case k0040: return V2Param(px,v2Param[2]); break;
+  }
+  return 0;
 }
 
+
 //--------------------------------------------------------------------------
 //
-//                             ThermRealGamma
+//                             DirectVirtGamma
 //
 //--------------------------------------------------------------------------
-Int_t AliGenEMlib::IpThermRealGamma(TRandom *)
-{
-  return 222000;
-}
-
-Double_t AliGenEMlib::PtThermRealGamma( const Double_t *px, const Double_t */*dummy*/ )
-{
-  return PtExponential(px,fgkThermPtParam[fgSelectedCentrality]);
-}
-
-Double_t AliGenEMlib::YThermRealGamma( const Double_t *px, const Double_t */*dummy*/ )
+Double_t AliGenEMlib::PtPromptVirtGamma( const Double_t *px, const Double_t */*dummy*/ )
 {
-  return YFlat(*px);
+  return IntegratedKrollWada(px,px)*PtPromptRealGamma(px,px);
 }
 
-Double_t AliGenEMlib::V2ThermRealGamma( const Double_t *px, const Double_t */*dummy*/ )
+Double_t AliGenEMlib::PtThermalVirtGamma( const Double_t *px, const Double_t */*dummy*/ )
 {
-  return KEtScal(*px,8);
+  return IntegratedKrollWada(px,px)*PtThermalRealGamma(px,px);
 }
 
-//--------------------------------------------------------------------------
-//
-//                             ThermVirtGamma
-//
-//--------------------------------------------------------------------------
-Int_t AliGenEMlib::IpThermVirtGamma(TRandom *)
+Double_t AliGenEMlib::PtDirectVirtGamma( const Double_t *px, const Double_t */*dummy*/ )
 {
-  return 224000;
+  return IntegratedKrollWada(px,px)*(PtPromptRealGamma(px,px)+PtThermalRealGamma(px,px));
 }
 
-Double_t AliGenEMlib::PtThermVirtGamma( const Double_t *px, const Double_t */*dummy*/ )
+Int_t AliGenEMlib::IpDirectVirtGamma(TRandom *)
 {
-  return IntegratedKrollWada(*px)*PtThermRealGamma(px,px);
+  return 220000;
 }
 
-Double_t AliGenEMlib::YThermVirtGamma( const Double_t *px, const Double_t */*dummy*/ )
+Double_t AliGenEMlib::YDirectVirtGamma( const Double_t *px, const Double_t */*dummy*/ )
 {
   return YFlat(*px);
 }
 
-Double_t AliGenEMlib::V2ThermVirtGamma( const Double_t *px, const Double_t */*dummy*/ )
+Double_t AliGenEMlib::V2DirectVirtGamma( const Double_t *px, const Double_t */*dummy*/ )
 {
-  return KEtScal(*px,8);
+  return V2DirectRealGamma(px,px);
 }
 
 //--------------------------------------------------------------------------
@@ -340,9 +327,12 @@ Int_t AliGenEMlib::IpPizero(TRandom *)
 
 Double_t AliGenEMlib::PtPizero( const Double_t *px, const Double_t */*dummy*/ )
 {
-  // double pigammacorr=2.385389e-01*log(*px+0.001)+1.557687e+00;
-  // pigammacorr*=9.513666e-03*log(*px+0.001)+9.509347e-01;
-  // return pigammacorr*PtPromptRealGamma(px,px);  //misuse pion for direct gammas
+  // double pigammacorr=1; //misuse pion for direct gammas, tuned for 0040, iteration 0
+  // pigammacorr*=2.258900e-01*log(*px+0.001)+1.591291e+00;  //iteration 1
+  // pigammacorr*=6.601943e-03*log(*px+0.001)+9.593698e-01;  //iteration 2
+  // pigammacorr*=4.019933e-03*log(*px+0.001)+9.843412e-01;  //iteration 3
+  // pigammacorr*=-4.543991e-03*log(*px+0.001)+1.010886e+00; //iteration 4
+  // return pigammacorr*PtPromptRealGamma(px,px); //now the gammas from the pi->gg decay have the pt spectrum of prompt real gammas
   
   // fit functions and corresponding parameter of Pizero pT for pp @ 2.76 TeV and @ 7 TeV and for PbPb @ 2.76 TeV 
 
@@ -358,6 +348,9 @@ Double_t AliGenEMlib::PtPizero( const Double_t *px, const Double_t */*dummy*/ )
   Double_t kb=0.;
   Double_t kd=0.;
 
+  double n1,n2,n3;
+  int oldCent;
+
   switch(fgSelectedPtParam|fgSelectedCentrality) {
     // fit to pi charged v1
     // charged pion from ToF, unidentified hadrons scaled with pion from TPC
@@ -407,7 +400,26 @@ Double_t AliGenEMlib::PtPizero( const Double_t *px, const Double_t */*dummy*/ )
     kc=2842.0; kp0=1.465; kp1=0.8324; kn=8.167; kcT=0.0001049; kT=2.29;
     return PtModifiedHagedornThermal(*px,kc,kp0,kp1,kn,kcT,kT);
     break;
-   
+  case kPichargedPbPb|k0020:
+    oldCent=fgSelectedCentrality;
+    fgSelectedCentrality=k0010;
+    n1=PtPizero(px,px);
+    fgSelectedCentrality=k1020;
+    n2=PtPizero(px,px);
+    fgSelectedCentrality=oldCent;
+    return (n1+n2)/2;
+    break;
+  case kPichargedPbPb|k0040:
+    oldCent=fgSelectedCentrality;
+    fgSelectedCentrality=k0010;
+    n1=PtPizero(px,px);
+    fgSelectedCentrality=k1020;
+    n2=PtPizero(px,px);
+    fgSelectedCentrality=k2040;
+    n3=PtPizero(px,px);
+    fgSelectedCentrality=oldCent;
+    return (n1+n2+2*n3)/4;
+    break;
 
     // fit to pizero from conversion analysis
     // for PbPb @ 2.76 TeV
@@ -502,7 +514,8 @@ Double_t AliGenEMlib::YPizero( const Double_t *py, const Double_t */*dummy*/ )
 
 Double_t AliGenEMlib::V2Pizero( const Double_t *px, const Double_t */*dummy*/ )
 {
-  double n1,n2,v1,v2;
+  double n1,n2,n3,n4,n5;
+  double v1,v2,v3,v4,v5;
   switch(fgSelectedCentrality) {
   case k0010:
     n1=PtModifiedHagedornPowerlaw(px,fgkRawPtOfV2Param[k0005]);
@@ -511,6 +524,15 @@ Double_t AliGenEMlib::V2Pizero( const Double_t *px, const Double_t */*dummy*/ )
     v2=V2Param(px,fgkV2param[k0510]);
     return (n1*v1+n2*v2)/(n1+n2);
     break;
+  case k0020:
+    n1=PtModifiedHagedornPowerlaw(px,fgkRawPtOfV2Param[k0005]);
+    v1=V2Param(px,fgkV2param[k0005]);
+    n2=PtModifiedHagedornPowerlaw(px,fgkRawPtOfV2Param[k0510]);
+    v2=V2Param(px,fgkV2param[k0510]);
+    n3=PtModifiedHagedornPowerlaw(px,fgkRawPtOfV2Param[k1020]);
+    v3=V2Param(px,fgkV2param[k1020]);
+    return (n1*v1+n2*v2+2*n3*v3)/(n1+n2+2*n3);
+    break;
   case k2040:
     n1=PtModifiedHagedornPowerlaw(px,fgkRawPtOfV2Param[k2030]);
     v1=V2Param(px,fgkV2param[k2030]);
@@ -518,6 +540,19 @@ Double_t AliGenEMlib::V2Pizero( const Double_t *px, const Double_t */*dummy*/ )
     v2=V2Param(px,fgkV2param[k3040]);
     return (n1*v1+n2*v2)/(n1+n2);
     break;
+  case k0040:
+    n1=PtModifiedHagedornPowerlaw(px,fgkRawPtOfV2Param[k0005]);
+    v1=V2Param(px,fgkV2param[k0005]);
+    n2=PtModifiedHagedornPowerlaw(px,fgkRawPtOfV2Param[k0510]);
+    v2=V2Param(px,fgkV2param[k0510]);
+    n3=PtModifiedHagedornPowerlaw(px,fgkRawPtOfV2Param[k1020]);
+    v3=V2Param(px,fgkV2param[k1020]);
+    n4=PtModifiedHagedornPowerlaw(px,fgkRawPtOfV2Param[k2030]);
+    v4=V2Param(px,fgkV2param[k2030]);
+    n5=PtModifiedHagedornPowerlaw(px,fgkRawPtOfV2Param[k3040]);
+    v5=V2Param(px,fgkV2param[k3040]);
+    return (n1*v1+n2*v2+2*n3*v3+2*n4*v4+2*n5*v5)/(n1+n2+2*n3+2*n4+2*n5);
+    break;
 
   default:
     return V2Param(px,fgkV2param[fgSelectedCentrality]);
@@ -717,7 +752,18 @@ Int_t AliGenEMlib::IpJpsi(TRandom *)
 Double_t AliGenEMlib::PtJpsi( const Double_t *px, const Double_t */*dummy*/ )
 {
   // Jpsi pT
-  return MtScal(*px,6);
+  // based on: //https://aliceinfo.cern.ch/Notes/node/242, https://aliceinfo.cern.ch/Figure/node/3457, www.sciencedirect.com/science/article/pii/S0370269312011446
+  const static Double_t jpsiPtParam[2][3] = {
+    {  9.686337e-03, 2.629441e-01, 4.552044e+00 }
+    ,{ 3.403549e-03, 2.897061e-01, 3.644278e+00 }
+  };
+  const double pt=px[0]*2.28/2.613;
+  switch(fgSelectedCentrality) {
+  case k0020: return 2.405*PtDoublePowerlaw(&pt,jpsiPtParam[0]); break;
+  case k2040: return 2.405*PtDoublePowerlaw(&pt,jpsiPtParam[1]); break;
+  case k0040: return 0.5*2.405*(PtDoublePowerlaw(&pt,jpsiPtParam[0])+PtDoublePowerlaw(&pt,jpsiPtParam[1])); break;
+  }
+  return 0;
 }
 
 Double_t AliGenEMlib::YJpsi( const Double_t *py, const Double_t */*dummy*/ )
@@ -779,14 +825,14 @@ Double_t AliGenEMlib::MtScal(Double_t pt, Int_t np)
   return norm*(pt/scaledPt)*scaledYield;
 }
 
-Double_t AliGenEMlib::KEtScal(const Double_t pt, Int_t np)
+Double_t AliGenEMlib::KEtScal(Double_t pt, Int_t np)
 {
   const int nq=2; //number of quarks for particle np, here always 2
   Double_t scaledPt = sqrt(pow(2.0/nq*(sqrt(pt*pt+fgkHM[np]*fgkHM[np])-fgkHM[np])+fgkHM[0],2)-fgkHM[0]*fgkHM[0]);
   // double val=V2Pizero(&scaledPt, (Double_t*) 0);
   // static const double syserr[12]={0., 0.09, 0.07, 0.06, 0.04, 0.04, 0.04, 0.05, 0., 0., 0., 0.}; //based on pi vs kaon
   // double sys=fgSelectedV2Systematic*min(fgkV2param[fgSelectedCentrality][0],fgkV2param[fgSelectedCentrality][8])*syserr[fgSelectedCentrality];
-  // return TMath::Max(val+sys,0.0);
+  // return std::max(val+sys,0.0);
   return V2Pizero(&scaledPt, (Double_t*) 0);
 }
 
@@ -797,7 +843,7 @@ Double_t AliGenEMlib::V2Param(const Double_t *px, const Double_t *par)
   const double &pt=px[0];
   double val=CrossOverLc(par[4],par[3],pt)*(2*par[0]/(1+TMath::Exp(par[1]*(par[2]-pt)))-par[0])+CrossOverRc(par[4],par[3],pt)*((par[8]-par[5])/(1+TMath::Exp(par[6]*(pt-par[7])))+par[5]);
   double sys=fgSelectedV2Systematic*par[11+fgSelectedV2Systematic*2]*pow(pt,par[12+fgSelectedV2Systematic*2]);
-  return TMath::Max(val+sys,0.0);
+  return std::max(val+sys,0.0);
 }
 
 Double_t AliGenEMlib::V2Flat(const Double_t */*px*/, const Double_t */*param*/)
@@ -845,17 +891,11 @@ GenFunc AliGenEMlib::GetPt(Int_t param, const char * tname) const
 
    switch (param) 
     {
-    case kPromptRealGamma:
-      func=PtPromptRealGamma;
-      break;
-    case kPromptVirtGamma:
-      func=PtPromptVirtGamma;
+     case kDirectRealGamma:
+       func=PtDirectRealGamma;
       break;
-    case kThermRealGamma:
-      func=PtThermRealGamma;
-      break;
-    case kThermVirtGamma:
-      func=PtThermVirtGamma;
+     case kDirectVirtGamma:
+       func=PtDirectVirtGamma;
       break;
     case kPizero:
       func=PtPizero;
@@ -894,17 +934,11 @@ GenFunc AliGenEMlib::GetY(Int_t param, const char * tname) const
 
    switch (param) 
     {
-    case kPromptRealGamma:
-      func=YPromptRealGamma;
-      break;
-    case kPromptVirtGamma:
-      func=YPromptVirtGamma;
+    case kDirectRealGamma:
+      func=YDirectRealGamma;
       break;
-    case kThermRealGamma:
-      func=YThermRealGamma;
-      break;
-    case kThermVirtGamma:
-      func=YThermVirtGamma;
+    case kDirectVirtGamma:
+      func=YDirectVirtGamma;
       break;
     case kPizero:
          func=YPizero;
@@ -943,17 +977,11 @@ GenFuncIp AliGenEMlib::GetIp(Int_t param, const char * tname) const
 
    switch (param) 
     {
-    case kPromptRealGamma:
-      func=IpPromptRealGamma;
-      break;
-    case kPromptVirtGamma:
-      func=IpPromptVirtGamma;
+    case kDirectRealGamma:
+      func=IpDirectRealGamma;
       break;
-    case kThermRealGamma:
-      func=IpThermRealGamma;
-      break;
-    case kThermVirtGamma:
-      func=IpThermVirtGamma;
+    case kDirectVirtGamma:
+      func=IpDirectVirtGamma;
       break;
     case kPizero:
          func=IpPizero;
@@ -992,17 +1020,11 @@ GenFunc AliGenEMlib::GetV2(Int_t param, const char * tname) const
 
   switch (param) 
     {
-    case kPromptRealGamma:
-      func=V2PromptRealGamma;
-      break;
-    case kPromptVirtGamma:
-      func=V2PromptVirtGamma;
-      break;
-    case kThermRealGamma:
-      func=V2ThermRealGamma;
+    case kDirectRealGamma:
+      func=V2DirectRealGamma;
       break;
-    case kThermVirtGamma:
-      func=V2ThermVirtGamma;
+    case kDirectVirtGamma:
+      func=V2DirectVirtGamma;
       break;
     case kPizero:
       func=V2Pizero;
index 6372507799bb3410a6c124d67e4a0e81d952af58..cf43e6f25df7b0667797e0b9e20936f67055d3f9 100644 (file)
@@ -21,7 +21,7 @@ class TRandom;
 class AliGenEMlib :public AliGenLib {
 public:
     
-  enum Particle_t{kPromptRealGamma, kPromptVirtGamma, kThermRealGamma, kThermVirtGamma, kPizero, kEta, kRho, kOmega, kEtaprime, kPhi, kJpsi};
+  enum Particle_t{kPizero=0, kEta, kRho, kOmega, kEtaprime, kPhi, kJpsi, kDirectRealGamma, kDirectVirtGamma };
   enum Centrality_t{kpp=0x0, k0005=0x1, k0510=0x2, k1020=0x3, k2030=0x4, k3040=0x5, k4050=0x6, k5060=0x7, k0010=0x8, k2040=0x9, k4060=0xA, k6080=0xB, k0020=0xC, k0040=0xD, k2080=0xE, k4080=0xF, kCentralities=0x10};
   enum PtParamSet_t{kPizero7TeVpp=0x10, kPizeroEta7TeVpp=0x20, kPizero7TeVpplow=0x30, kPizeroEta7TeVpplow=0x40, kPizero7TeVpphigh=0x50, kPizeroEta7TeVpphigh=0x60, kPizero2760GeVpp=0x70, kPizeroEta2760GeVpp=0x80, kPizero2760GeVpplow=0x90, kPizeroEta2760GeVpplow=0xA0, kPizero2760GeVpphigh=0xB0, kPizeroEta2760GeVpphigh=0xC0, kPichargedPbPb=0xD0, kPizeroPbPb=0xE0, kPichargedPPb=0xF0 };
   enum v2Sys_t{kLoV2Sys=-1, kNoV2Sys=0, kUpV2Sys=+1};
@@ -45,65 +45,60 @@ public:
   static Int_t fgSelectedV2Systematic; // selected v2 systematics, usefully values: -1,0,1
 
 
-  static Double_t PtModifiedHagedornThermal(const Double_t pt, 
-                                           const Double_t c, 
-                                           const Double_t p0, 
-                                           const Double_t p1, 
-                                           const Double_t n,
-                                           const Double_t cT,
-                                           const Double_t T);
+  static Double_t PtModifiedHagedornThermal(Double_t pt, 
+                                           Double_t c, 
+                                           Double_t p0, 
+                                           Double_t p1, 
+                                           Double_t n,
+                                           Double_t cT,
+                                           Double_t T);
 
 
  
-  static Double_t PtModifiedHagedornExp(const Double_t pt,
-                                       const Double_t c,
-                                       const Double_t p0,
-                                       const Double_t p1,
-                                       const Double_t p2,
-                                       const Double_t n); 
-
-
-  static Double_t PtModifiedHagedornExp2(const Double_t pt,
-                                           const Double_t c,
-                                           const Double_t a,
-                                           const Double_t b,
-                                           const Double_t p0,
-                                           const Double_t p1,
-                                           const Double_t d,
-                                           const Double_t n);
-
-
-  static Double_t PtTsallis(const Double_t pt,
-                           const Double_t m,
-                           const Double_t c,
-                           const Double_t T,
-                           const Double_t n);
+  static Double_t PtModifiedHagedornExp(Double_t pt,
+                                       Double_t c,
+                                       Double_t p0,
+                                       Double_t p1,
+                                       Double_t p2,
+                                       Double_t n); 
+
+
+  static Double_t PtModifiedHagedornExp2(Double_t pt,
+                                           Double_t c,
+                                           Double_t a,
+                                           Double_t b,
+                                           Double_t p0,
+                                           Double_t p1,
+                                           Double_t d,
+                                           Double_t n);
+
+
+  static Double_t PtTsallis(Double_t pt,
+                           Double_t m,
+                           Double_t c,
+                           Double_t T,
+                           Double_t n);
 
   static Double_t PtExponential(const Double_t *pt, const Double_t *param);
   static Double_t PtModifiedHagedornPowerlaw(const Double_t *pt, const Double_t *param);
-  static Double_t IntegratedKrollWada(Double_t mh);
+  static Double_t PtDoublePowerlaw(const Double_t *pt, const Double_t *param);
+  static Double_t IntegratedKrollWada(const Double_t *mh, const Double_t *);
 
-  // prompt gamma
-  static Int_t    IpPromptRealGamma(TRandom *ran);
+  // direct gamma
   static Double_t PtPromptRealGamma(const Double_t *px, const Double_t *dummy);
-  static Double_t YPromptRealGamma(const Double_t *py, const Double_t *dummy);
-  static Double_t V2PromptRealGamma(const Double_t *px, const Double_t *dummy);
-
-  static Int_t    IpPromptVirtGamma(TRandom *ran);
   static Double_t PtPromptVirtGamma(const Double_t *px, const Double_t *dummy);
-  static Double_t YPromptVirtGamma(const Double_t *py, const Double_t *dummy);
-  static Double_t V2PromptVirtGamma(const Double_t *px, const Double_t *dummy);
+  static Double_t PtThermalRealGamma(const Double_t *px, const Double_t *dummy);
+  static Double_t PtThermalVirtGamma(const Double_t *px, const Double_t *dummy);
 
-  // thermal gamma
-  static Int_t    IpThermRealGamma(TRandom *ran);
-  static Double_t PtThermRealGamma(const Double_t *px, const Double_t *dummy);
-  static Double_t YThermRealGamma(const Double_t *py, const Double_t *dummy);
-  static Double_t V2ThermRealGamma(const Double_t *px, const Double_t *dummy);
+  static Int_t    IpDirectRealGamma(TRandom *ran);
+  static Double_t PtDirectRealGamma(const Double_t *px, const Double_t *dummy);
+  static Double_t YDirectRealGamma(const Double_t *py, const Double_t *dummy);
+  static Double_t V2DirectRealGamma(const Double_t *px, const Double_t *dummy);
 
-  static Int_t    IpThermVirtGamma(TRandom *ran);
-  static Double_t PtThermVirtGamma(const Double_t *px, const Double_t *dummy);
-  static Double_t YThermVirtGamma(const Double_t *py, const Double_t *dummy);
-  static Double_t V2ThermVirtGamma(const Double_t *px, const Double_t *dummy);
+  static Int_t    IpDirectVirtGamma(TRandom *ran);
+  static Double_t PtDirectVirtGamma(const Double_t *px, const Double_t *dummy);
+  static Double_t YDirectVirtGamma(const Double_t *py, const Double_t *dummy);
+  static Double_t V2DirectVirtGamma(const Double_t *px, const Double_t *dummy);
 
   // Pizero
     static Int_t    IpPizero(TRandom *ran);
@@ -156,8 +151,8 @@ public:
   static Double_t KEtScal(Double_t pt, Int_t np);
   static Double_t GetTAA(Int_t cent);
 
-  static Double_t CrossOverLc(const double a, const double b, const double x);
-  static Double_t CrossOverRc(const double a, const double b, const double x);
+  static Double_t CrossOverLc(double a, double b, double x);
+  static Double_t CrossOverRc(double a, double b, double x);
 
   static const Double_t fgkV2param[16][15];          // parameters of pi v2
   static const Double_t fgkRawPtOfV2Param[16][10];   // parameters of the raw pt spectrum of v2 analysys
index 3e92b14c9c3e1f9db3d7060ddc42fcbf21288ec5..a2dafd2b1ba6acad2dc6eb0b30e561f463b49bc8 100644 (file)
@@ -225,11 +225,6 @@ void AliGenParam::RotateVector(Double_t *pin, Double_t *pout, Double_t costheta,
   return;
 }
 
-Double_t AliGenParam::IntegratedKrollWada(Double_t mh){
-  if(mh<0.003) return 0;
-  return 2*log(mh/0.000511/exp(7.0/4.0))/411.0/TMath::Pi();
-}
-
 double AliGenParam::ScreenFunction1(double screenVariable){
   if(screenVariable>1)
     return 42.24 - 8.368 * log(screenVariable + 0.952);
@@ -321,8 +316,8 @@ Double_t AliGenParam::RandomMass(Double_t mh){
   while(true){
     double y=fRandom->Rndm();
     double mee=2*0.000511*TMath::Power(2*0.000511/mh,-y); //inverse of the enveloping cumulative distribution
-    double apxkw=2.0/3.0/137.036/TMath::Pi()/mee;
-    double val=fRandom->Uniform(0,apxkw);  //enveloping probability density0
+    double apxkw=2.0/3.0/137.036/TMath::Pi()/mee; //enveloping probability density
+    double val=fRandom->Uniform(0,apxkw);
     double kw=apxkw*sqrt(1-4*0.000511*0.000511/mee/mee)*(1+2*0.000511*0.000511/mee/mee)*1*1*TMath::Power(1-mee*mee/mh/mh,3);
     if(val<kw)
       return mee;
@@ -334,8 +329,8 @@ Int_t AliGenParam::VirtualGammaPairProduction(TClonesArray *particles, Int_t nPa
   Int_t nPartNew=nPart;
   for(int iPart=0; iPart<nPart; iPart++){      
     TParticle *gamma = (TParticle *) particles->At(iPart);
-    if(gamma->GetPdgCode()!=223000 || gamma->GetPdgCode()!=224000) continue;
-    //if(gamma->Energy()<0.001022) continue; //can never be
+    if(gamma->GetPdgCode()!=220000) continue;
+    if(gamma->Pt()<0.002941) continue;  //approximation of kw in AliGenEMlib is 0 below 0.002941
     double mass=RandomMass(gamma->Pt());
 
     // lepton pair kinematics in virtual photon rest frame 
@@ -378,6 +373,7 @@ Int_t AliGenParam::VirtualGammaPairProduction(TClonesArray *particles, Int_t nPa
     new((*particles)[nPartNew]) TParticle(-11, gamma->GetStatusCode(), iPart+1, -1, 0, 0, e2V4, vtx);
     nPartNew++;
   }
+  return nPartNew;
 }
 
 Int_t AliGenParam::ForceGammaConversion(TClonesArray *particles, Int_t nPart)
@@ -390,7 +386,6 @@ Int_t AliGenParam::ForceGammaConversion(TClonesArray *particles, Int_t nPart)
     TParticle *gamma = (TParticle *) particles->At(iPart);
     if(gamma->GetPdgCode()!=22) continue;
     if(gamma->Energy()<0.001022) continue;
-
     TVector3 gammaV3(gamma->Px(),gamma->Py(),gamma->Pz());
     double frac=RandomEnergyFraction(1,gamma->Energy());
     double Ee1=frac*gamma->Energy();
@@ -424,8 +419,7 @@ Int_t AliGenParam::ForceGammaConversion(TClonesArray *particles, Int_t nPart)
     new((*particles)[nPartNew]) TParticle(-11, gamma->GetStatusCode(), iPart+1, -1, 0, 0, TLorentzVector(e2V3,Ee2), vtx);
     nPartNew++;
   }
-  // particles->Compress();
-  return particles->GetEntriesFast();
+  return nPartNew;
 }
 
 //____________________________________________________________
@@ -579,7 +573,7 @@ void AliGenParam::GenerateN(Int_t ntimes)
       Int_t iTemp = iPart;
 
       // custom pdg codes for to destinguish direct photons
-      if((iPart>=221000) && (iPart<=229000)) iPart=22;
+      if(iPart==220000) iPart=22;
 
          fChildWeight=(fDecayer->GetPartialBranchingRatio(iPart))*fParentWeight;          
          TParticlePDG *particle = pDataBase->GetParticle(iPart);
@@ -664,13 +658,12 @@ void AliGenParam::GenerateN(Int_t ntimes)
              Int_t np=fDecayer->ImportParticles(particles);
 
        iPart=iTemp;
-       if(fForceConv) np=ForceGammaConversion(particles,np);
-       if(iPart==223000 || iPart==224000){
-         // wgtp*=IntegratedKrollWada(pt);
-         // wgtch*=IntegratedKrollWada(pt);
-         // np=VirtualGammaPairProduction(particles,np)
+       if(iPart==220000){
+         TParticle *gamma = (TParticle *)particles->At(0);
+         gamma->SetPdgCode(iPart);
+         np=VirtualGammaPairProduction(particles,np);
        }
-
+       if(fForceConv) np=ForceGammaConversion(particles,np);
 
              //  Selecting  GeometryAcceptance for particles fPdgCodeParticleforAcceptanceCut;
              if (fGeometryAcceptance) 
index 522096aee8ee89b755eeb1791d830cbfceffa502..b00789c619862c9dc7365bea035b000afece47b4 100644 (file)
@@ -55,7 +55,6 @@ public:
     static TVector3 OrthogonalVector(TVector3 &inVec);
     static void RotateVector(Double_t *pin, Double_t *pout, Double_t costheta, Double_t sintheta,
                           Double_t cosphi, Double_t sinphi);
-    static double IntegratedKrollWada(Double_t mh);
     static double ScreenFunction1(double d);
     static double ScreenFunction2(double d);
     double RandomEnergyFraction(double Z, double E);
index 134a6e7b3aa8d4f341c9784eea0cdf95d0292b5e..b7d4564962158daf3ef861563b23b69505596f80 100644 (file)
@@ -37,6 +37,8 @@
 
 using std::cout;
 using std::endl;
+using std::ios_base;
+
 ClassImp(AliFITRawData)
 
 //_____________________________________________________________________________
index 230523fe3822a9481889c26197357da0aef7f36e..9ebb1f6f03914eb2cab277825482638575b23c2c 100644 (file)
@@ -35,6 +35,9 @@
 #include <TMath.h>
 #include <Riostream.h>
 
+using std::cout;
+using std::endl;
+
 ClassImp(AliFITReconstructor)
 
 AliFITReconstructor:: AliFITReconstructor(): AliReconstructor(),
index b898217967bc531d0a67a1fe773b9b62c8566444..a230b0c6a15b47b5d037142fe2964ac83a977de0 100644 (file)
@@ -312,6 +312,13 @@ AliFMDReconstructor::MarkDeadChannels(AliESDFMD* esd) const
 
       for (UShort_t s = 0; s < nS; s++) { 
        for (UShort_t t = 0; t < nT; t++) {
+         // A strip can be marked `bad' for two reasons: 
+         // 
+         // - The raw reader fails to read the value 
+         // - The strip is marked in OCDB as bad (IsDead) 
+         // 
+         // Hence, a dead strip will always be marked kInvalid here, 
+         // while a non-dead bad-read strip will be filled with 0. 
          if (fBad(d, r, s, t)) { 
            AliDebug(5, Form("Marking FMD%d%c[%2d,%3d] as bad", d, r, s, t));
            esd->SetMultiplicity(d, r, s, t, AliESDFMD::kInvalidMult);
@@ -333,15 +340,58 @@ AliFMDReconstructor::MarkDeadChannels(AliESDFMD* esd) const
 }
 
 //____________________________________________________________________
-void 
-AliFMDReconstructor::Reconstruct(AliFMDRawReader& rawReader) const
+Bool_t
+AliFMDReconstructor::PreReconstruct() const
 {
-  AliFMDDebug(1, ("Reconstructing from FMD raw reader"));
+  AliFMDDebug(1, ("Before reoconstructing"));
   if (fZombie) { 
     AliWarning("I'm a zombie - cannot do anything");
-    return;
+    return false;
   }
+
+  // Get our vertex
+  GetVertex(fESD);
+
+  // Reset bad flags 
   fBad.Reset(false);
+
+  // Reset the output ESD 
+  if (fESDObj) {
+    fESDObj->Clear();
+    
+    // Pre-set eta values 
+    for (UShort_t d=1; d<=3; d++) { 
+      UShort_t nQ = (d == 1 ? 1 : 2);
+      for (UShort_t q=0; q<nQ; q++) { 
+       UShort_t nStr = (q == 0 ? 512 : 256);
+       Char_t   r    = (q == 0 ? 'I' : 'O');
+       
+       for (UShort_t t = 0; t < nStr; t++) { 
+         Float_t eta, phi;
+         // Always use sector 0
+         PhysicalCoordinates(d, r, 0, t, eta, phi);
+         fESDObj->SetEta(d, r, 0, t, eta);
+       }
+      }
+    }
+  }
+
+
+  return true;
+}
+
+//____________________________________________________________________
+void 
+AliFMDReconstructor::Reconstruct(AliFMDRawReader& rawReader) const
+{
+  // Reconstruct directly from raw data (no intermediate output on
+  // digit tree or rec point tree).  
+  // 
+  // Parameters: 
+  //   rawReader       FMD Raw event reader 
+  AliFMDDebug(1, ("Reconstructing from FMD raw reader"));
+  if (!PreReconstruct()) return;
+
   UShort_t det, sec, str, fac;
   Short_t  adc, oldDet = -1;
   Bool_t   zs;
@@ -427,19 +477,15 @@ AliFMDReconstructor::Reconstruct(TTree* digitsTree,
   //   digitsTree      Pointer to a tree containing digits 
   //   clusterTree     Pointer to output tree 
   // 
-  if (fZombie) { 
-    AliWarning("I'm a zombie - cannot do anything");
-    return;
-  }
+  if (!PreReconstruct()) return;
+
   if (!fMult) fMult = new TClonesArray("AliFMDRecPoint");
 
   AliFMDDebug(1, ("Reconstructing from digits in a tree"));
-  GetVertex(fESD);
-
 
-
-  static TClonesArray* digits = new TClonesArray("AliFMDDigit");
-  TBranch*      digitBranch   = digitsTree->GetBranch("FMD");
+  // Get the digitis array 
+  static TClonesArray* digits      = new TClonesArray("AliFMDDigit");
+  TBranch*             digitBranch = digitsTree->GetBranch("FMD");
   if (!digitBranch) {
     Error("Exec", "No digit branch for the FMD found");
     return;
@@ -448,8 +494,8 @@ AliFMDReconstructor::Reconstruct(TTree* digitsTree,
 
   if (digits)  digits->Clear();
   if (fMult)   fMult->Clear();
-  if (fESDObj) fESDObj->Clear();
-  
+
+  // Create rec-point output branch 
   fNMult = 0;
   fTreeR = clusterTree;
   fTreeR->Branch("FMD", &fMult);
@@ -570,8 +616,7 @@ AliFMDReconstructor::ProcessSignal(UShort_t det,
   
   // digit->Print();
   // Get eta and phi 
-  Float_t eta, phi;
-  PhysicalCoordinates(det, rng, sec, str, eta, phi);
+  Float_t eta = fESDObj->Eta(det, rng, 0, str);
     
   // Substract pedestal. 
   UShort_t counts   = SubtractPedestal(det, rng, sec, str, adc);
@@ -597,6 +642,9 @@ AliFMDReconstructor::ProcessSignal(UShort_t det,
   
   // Create a `RecPoint' on the output branch. 
   if (fMult) {
+    Float_t phi;
+    PhysicalCoordinates(det, rng, sec, str, eta, phi);
+
     AliFMDRecPoint* m = 
       new ((*fMult)[fNMult]) AliFMDRecPoint(det, rng, sec, str, 
                                            eta, phi, edep, mult);
@@ -605,7 +653,7 @@ AliFMDReconstructor::ProcessSignal(UShort_t det,
   }
   
   fESDObj->SetMultiplicity(det, rng, sec, str, mult);
-  fESDObj->SetEta(det, rng, sec, str, eta);
+  // fESDObj->SetEta(det, rng, sec, str, eta);
   
   if (fDiagAll) fDiagAll->Fill(adc, mult);  
 
@@ -685,7 +733,7 @@ AliFMDReconstructor::SubtractPedestal(UShort_t det,
   //  
   AliFMDParameters* param  = AliFMDParameters::Instance();
   Float_t           ped    = (zsEnabled ? 0 : 
-                               param->GetPedestal(det, rng, sec, str));
+                             param->GetPedestal(det, rng, sec, str));
   Float_t           noise  = param->GetPedestalWidth(det, rng, sec, str);
   if(ped < 0 || noise < 0) { 
     AliWarningClass(Form("Invalid pedestal (%f) or noise (%f) "
index 1107c716f88e9345849d796168fa37b66c42a405..6553f6c892e4805d3d0e0c17e29ba8bf1cfce989 100644 (file)
@@ -83,8 +83,11 @@ public:
    * AliFMDAltroReader.  The digits are put in the passed TTree @a
    * digitsTree. 
    *
-   * @param reader     Raw reader. 
-   * @param digitsTree Tree to store read digits in. 
+   * @note This is the first part of the reconstruction as done by the
+   * offical steering class AliReconstruction.
+   *
+   * @param reader Raw reader.  @param digitsTree Tree to store read
+   * digits in.
    */
   virtual void   ConvertDigits(AliRawReader* reader, TTree* digitsTree) const;
   /** 
@@ -93,6 +96,9 @@ public:
    * them on the output tree @a clusterTree.  An FMD ESD object is
    * created in parallel. 
    *
+   * @note This is the second part of the reconstruction as done by
+   * the offical steering class AliReconstruction.
+   *
    * @param digitsTree  Tree holding the digits of this event
    * @param clusterTree Tree to store AliFMDRecPoint objects in. 
    */
@@ -104,11 +110,22 @@ public:
    *       TClonesArray of AliFMDDigits
    */
   virtual void   Reconstruct(AliRawReader *, TTree*) const;
+  /** 
+   * Not used.
+   *
+   * @todo This is called by the above same member function but with a
+   * pointer to a AliRawReader object and a pointer to a TTree object.
+   *
+   * @param reader Reader object 
+   */
   virtual void Reconstruct(AliFMDRawReader& reader) const;
   /** 
    * Put in the ESD data, the FMD ESD data.  The object created by
    * the Reconstruct member function is copied to the ESD object. 
    *
+   * @note This is the third part of the reconstruction as done by
+   * the offical steering class AliReconstruction.
+   *
    * @param digitsTree   Tree of digits for this event - not used
    * @param clusterTree  Tree of reconstructed points for this event -
    *        not used.
@@ -195,6 +212,12 @@ protected:
    * @return reference to this object 
    */
   AliFMDReconstructor& operator=(const AliFMDReconstructor&); //Not implemented
+  /** 
+   * Run some checks before reconstruction, clear internal arrays, etc. 
+   * 
+   * @return true on success 
+   */
+  Bool_t PreReconstruct() const;
   /** 
    * Try to get the vertex from either ESD or generator header.  Sets
    * @c fCurrentVertex to the found Z posistion of the vertex (if 
index b2bc9cdaf21d7c053ec01497d93cbc062e6ca3ca..0e67dad170097d971426e5283037e6723d082d5e 100644 (file)
@@ -90,6 +90,7 @@
 
 class TParticle;
 
+using std::istream;
 class AliITShit : public AliHit {
 
  public:
index f0a2516ea4b9bc4944ee5cecc206819fe1778480..04154ff7fd4049fe7a8ee1769a32367ba9ab15d3 100644 (file)
@@ -1,6 +1,9 @@
 #include "AliITSUClusterLines.h"
 #include <TMath.h>
 
+using std::cout;
+using std::endl;
+
 ClassImp(AliITSUClusterLines);
 
 //////////////////////////////////////////////////////////////////////
index 50586746ff9acea3e7f85352fc51db030bc1c079..a858f83b4626e693e08c66efa510c9b23f612f5f 100644 (file)
@@ -10,6 +10,9 @@
 #include <TObject.h>
 #include <Riostream.h>
 #include "AliStrLine.h"
+#include <vector>
+
+using std::vector;
 
 
 class AliITSUClusterLines : public TObject {
index db1e2004cc085d176d513612599dbfd274593873..9885530ff4d55e0e2e9a30247b0f5dcd5c814c9b 100644 (file)
@@ -1,3 +1,4 @@
+#include <Riostream.h>
 #include "TMath.h"
 #include "AliITSUSuze02.h"
 
@@ -8,6 +9,9 @@
 //  
 //*******************************************************************
 
+using std::cout;
+using std::endl;
+
 ClassImp(AliITSUSuze02)
 
 AliITSUSuze02::AliITSUSuze02(Int_t Nrows, Int_t Ncols):
diff --git a/ITS/UPGRADE/AliITSUTrackerSA.cxx b/ITS/UPGRADE/AliITSUTrackerSA.cxx
new file mode 100755 (executable)
index 0000000..883f282
--- /dev/null
@@ -0,0 +1,308 @@
+//-------------------------------------------------------------------------
+//               Implementation of the ITS tracker class
+//    It reads AliITSUClusterPix clusters and and fills the ESD with tracks
+//-------------------------------------------------------------------------
+
+#include <TBranch.h>
+#include <TMath.h>
+using TMath::Abs;
+using TMath::Sort;
+using TMath::Sqrt;
+#include <TTree.h>
+
+// Vc library
+//#include "Vc/Vc"
+//#include "AliITSUTrackerSAauxVc.h" // Structs and other stuff using Vc library  
+
+#include "AliESDEvent.h"
+#include "AliITSUClusterPix.h"
+#include "AliITSUTrackerSA.h"
+
+//#include "AliITSUtrackSA.h"      // Some dedicated SA track class ?  
+
+ClassImp(AliITSUTrackerSA)
+
+//________________________________________________________________________________
+AliITSUTrackerSA::AliITSUTrackerSA() : AliTracker(), 
+  fClusters(),
+  fClustersTC(),
+  fDoublets(),
+  fIndex(),
+  fNClusters(),
+  fNDoublets(),
+  fPhiCut(0.05),
+  fRPhiCut(0.01),
+  fZCut(0.005)
+{
+  //--------------------------------------------------------------------
+  // This default constructor needs to be provided
+  //--------------------------------------------------------------------
+  for(Int_t i=0;i<7;++i) {
+    fClusters[i].reserve(5000);
+  }
+}
+
+//________________________________________________________________________________
+AliITSUTrackerSA::AliITSUTrackerSA(const AliITSUTrackerSA &t): 
+  AliTracker(t),
+  fClusters(),
+  fClustersTC(),
+  fIndex(),
+  fNClusters(),
+  fNDoublets(),
+  fPhiCut(),
+  fRPhiCut(),
+  fZCut()
+{
+  //--------------------------------------------------------------------
+  // The copy constructor is protected
+  //--------------------------------------------------------------------
+}
+
+//________________________________________________________________________________
+Int_t AliITSUTrackerSA::Clusters2Tracks(AliESDEvent */*event*/) {
+  //--------------------------------------------------------------------
+  // This is the main tracking function
+  // The clusters must already be loaded
+  //--------------------------------------------------------------------
+
+  // Possibly, create the track "seeds" (combinatorial)
+
+  // Possibly, increment the seeds with additional clusters (Kalman)
+
+  // Possibly, (re)fit the found tracks 
+
+  // Tree iterations: 
+  // - High momentum first;
+  // - Low momentum with vertex constraint; 
+  // - Everything else. 
+
+  MakeDoublets();       // To be implemented
+  //MakeTriplets();       // Are triplets really necessary? MFT does not use them. 
+  CASelection();        // To be implemented
+  GlobalFit();          // To be implemented
+  ChiSquareSelection(); // To be implemented
+
+  return 0;
+}
+
+//________________________________________________________________________________
+Int_t AliITSUTrackerSA::PropagateBack(AliESDEvent */*event*/) {
+  //--------------------------------------------------------------------
+  // Here, we implement the Kalman smoother ?
+  // The clusters must be already loaded
+  //--------------------------------------------------------------------
+
+  return 0;
+}
+
+//________________________________________________________________________________
+Int_t AliITSUTrackerSA::RefitInward(AliESDEvent */*event*/) {
+  //--------------------------------------------------------------------
+  // Some final refit, after the outliers get removed by the smoother ?  
+  // The clusters must be loaded
+  //--------------------------------------------------------------------
+
+  return 0;
+}
+
+Int_t AliITSUTrackerSA::LoadClusters(TTree *cluTree) {
+  //--------------------------------------------------------------------
+  // This function reads the ITSU clusters from the tree,
+  // sort them, distribute over the internal tracker arrays, etc
+  //--------------------------------------------------------------------
+  
+  for(Int_t i=0;i<7;++i) {
+    TBranch* br = cluTree->GetBranch(Form("ITSRecPoints%d",i));
+    if (!br) return -1;
+    br->SetAddress(&fClustersTC[i]);
+  }    
+  cluTree->GetEntry(0);
+  
+  for(int iL=0; iL<7; ++iL) {
+    TClonesArray *clCont=&fClustersTC[iL];
+    fNClusters[iL]=clCont->GetEntriesFast();
+    Float_t phi[fNClusters[iL]];
+    fIndex[iL] = new Int_t[fNClusters[iL]];
+    for(int iC=0;iC<fNClusters[iL];++iC) {
+      const AliITSUClusterPix *cl = (AliITSUClusterPix*)clCont->At(iC);
+      float pos[3];
+      cl->GetGlobalXYZ(pos);
+      phi[iC] = pos[0]==0.f ? TMath::PiOver2() : TMath::ATan2(pos[1]-GetY(),pos[0]-GetX());
+      float angle=0.f; // TO BE UNDERSTOOD: DO I STILL NEED THE STATION ANGLE IF I USE THE GLOBAL COVARIANCE MATRIX?
+      fClusters[iL].push_back(itsCluster(pos[0],pos[1],pos[2],cl->GetSigmaY2(),cl->GetSigmaZ2(),cl->GetSigmaYZ(),phi[iC],angle));
+    }
+    TMath::Sort(fNClusters[iL],phi,fIndex[iL],kFALSE);
+  }
+  
+  return 0;
+}
+
+//________________________________________________________________________________
+void AliITSUTrackerSA::UnloadClusters() {
+  //--------------------------------------------------------------------
+  // This function unloads ITSU clusters from the RAM
+  //--------------------------------------------------------------------
+  for(int i=0;i<7;++i) {
+    fClusters[i].clear();
+    fNClusters[i]=0;
+    delete fIndex[i];
+  }
+  for(int i=0;i<6;++i) fDoublets[i].clear();
+}
+
+//________________________________________________________________________________
+AliCluster *AliITSUTrackerSA::GetCluster(Int_t /*index*/) const {
+  //--------------------------------------------------------------------
+  //       Return pointer to a given cluster
+  //--------------------------------------------------------------------
+  return 0;  // replace with an actual pointer 
+}
+
+//________________________________________________________________________________
+void AliITSUTrackerSA::CASelection() {
+  // Here it's implemented the Cellular Automaton routine
+  // Firstly the level of each doublet is set according to the level of 
+  // the neighbour doublets. 
+  // Doublet are considered to be neighbour if they share one point and the 
+  // phi and theta direction difference of the two is below a cut value.
+
+  for( int iL = 1; iL < 6; ++iL ) {
+    
+    const itsCluster* clusters1 = &fClusters[iL-1][0];
+    const itsCluster* clusters2 = &fClusters[iL][0];
+    const itsCluster* clusters3 = &fClusters[iL+1][0];    
+
+    const nPlets* doublets1 = &fDoublets[iL-1][0];
+    nPlets* doublets2 = &fDoublets[iL][0];
+
+    for ( int iD2 = 0; iD2 < fNDoublets[iL]; ++iD2 ) {
+      for ( int iD1 = 0; iD1 < fNDoublets[iL-1]; ++iD1 ) {
+       const int id1 = doublets1[iD1].id1;
+       const int id2 = doublets2[iD2].id0;
+       if ( id1 == id2 ) {
+         if ( doublets2[iD2].level <= ( doublets1[iD1].level + 1 ) ) {
+           const int id3 = doublets2[iD2].id1;
+           const float r3 = Sqrt( clusters3[id3].x * clusters3[id3].x + clusters3[id3].y * clusters3[id3].y );
+           const float r2 = Sqrt( clusters3[id2].x * clusters2[id2].x + clusters2[id2].y * clusters2[id2].y );
+           const float extrZ3 = doublets1[iD1].tanLambda * ( r3 - r2 ) + clusters3[id3].z ;
+           if ( Abs ( extrZ3 - clusters3[id3].z ) < fZCut ) {
+             const float det = (GetX() - clusters2[id2].x)*(GetY() - clusters1[id1].y) - (GetY() - clusters2[id2].y)*(GetX() - clusters1[id1].x);
+             if ( Abs(det) <= 1e-12 ) {
+               // linear extrapolation to next layer
+               const float dsq = ( doublets1[iD1].tanPhi * (clusters3[id3].x + clusters2[id2].x) + clusters3[id3].y - clusters2[id2].y ) * 
+                 ( doublets1[iD1].tanPhi * (clusters3[id3].x + clusters2[id2].x) + clusters3[id3].y - clusters2[id2].y ) / (1 + doublets1[iD1].tanPhi * doublets1[iD1].tanPhi );
+               if ( dsq < fRPhiCut*fRPhiCut )  {
+                 doublets2[iD2].level += doublets1[iD1].level;
+                 doublets2[iD2].neighbours.push_back(iD1);
+               }
+             } else {
+               const float r1sq = clusters1[id1].x * clusters1[id1].x + clusters1[id1].y * clusters1[id1].y ;
+               const float rvsq = GetX() * GetX() + GetY() * GetY();
+               const float deta = (r2*r2-rvsq) * (GetY() - clusters1[id1].y) - (r1sq-rvsq) * (GetY() - clusters2[id2].y);
+               const float detb =  (r2*r2-rvsq) * (GetX() - clusters1[id1].x) - (r1sq-rvsq) * (GetX() - clusters2[id2].x) ;
+               const float a = deta/det ;
+               const float b = detb/det ;
+               const float c = -rvsq - a * GetX() - b * GetY();
+               const float rc = Sqrt( a*a/4.f + b*b/4.f - c );
+               const float d = Sqrt( (a/2.f + clusters3[id3].x) * (a/2.f + clusters3[id3].x) + (b/2.f + clusters3[id3].y) * (b/2.f + clusters3[id3].y) );
+               if ( ( d - rc ) < fRPhiCut ) {
+                 doublets2[iD2].level += doublets1[iD1].level;
+                 doublets2[iD2].neighbours.push_back(iD1);
+               }
+             }
+           }
+         }
+       }
+      }
+    }
+  }
+
+  for ( int level = 6; level >=3 ; --level ) {
+    //vector<int> points[6];
+    for ( int doubl = 5; doubl >= 0; --doubl ) {
+      if( ( doubl + 1 - level ) < 0 ) break;
+      for ( int iD = 0; iD < fNDoublets[doubl]; ++iD ) {
+       if ( fDoublets[doubl][iD].level == level ) {
+         
+       }
+      }
+    }
+  }
+}
+
+//________________________________________________________________________________
+void AliITSUTrackerSA::MakeDoublets() {
+  // Make associations between two points on adjacent layers within an azimuthal window. 
+  // Under consideration:
+  // - track parameter estimation using the primary vertex position
+  // To do:
+  // - last iteration
+
+  for( int iL = 0 ; iL < 6 ; ++iL ) {
+    fNDoublets[iL] = 0; 
+    const itsCluster* clusters1 = &fClusters[iL][0];
+    const itsCluster* clusters2 = &fClusters[iL+1][0];
+
+    // 0 - 2Pi junction treatment (part I)
+    for ( int iC1 = 0 ; iC1 < fNClusters[iL] ; ++iC1 ) {
+      bool flag = true;
+      for ( int iC2 = fNClusters[iL]-1; iC2 > -1 ; --iC2 ) {
+       
+       if( (TMath::TwoPi() - (clusters2[iC2].phi-clusters1[iC1].phi) ) < fPhiCut ) {
+         fDoublets[iL].push_back(nPlets(iC1,iC2));
+         fDoublets[iL][fNDoublets[iL]].tanPhi = (clusters1[iC1].y-clusters2[iC2].y)/(clusters1[iC1].x-clusters2[iC2].x);
+         float r1  = Sqrt(clusters1[iC1].x * clusters1[iC1].x + clusters1[iC1].y * clusters1[iC1].y);
+         float r2  = Sqrt(clusters2[iC2].x * clusters2[iC2].x + clusters2[iC2].y * clusters2[iC2].y);
+         fDoublets[iL][fNDoublets[iL]].tanLambda = (clusters1[iC1].z-clusters2[iC2].z)/(r1-r2);
+         ++fNDoublets[iL];
+         flag = false;
+       } else break;
+
+      }
+      if (flag) break;
+    }
+
+    
+    // "Central" points 
+    for ( int iC1 = 0 ; iC1 < fNClusters[iL] ; ++iC1 ) {
+
+      for ( int iC2 = 0; iC2 < fNClusters[iL+1] ; ++iC2 ) {
+       
+       if( Abs( clusters1[iC1].phi - clusters2[iC2].phi ) < fPhiCut ) {
+         fDoublets[iL].push_back(nPlets(iC1,iC2));
+         fDoublets[iL][fNDoublets[iL]].tanPhi = (clusters1[iC1].y-clusters2[iC2].y)/(clusters1[iC1].x-clusters2[iC2].x);
+         float r1  = Sqrt(clusters1[iC1].x * clusters1[iC1].x + clusters1[iC1].y * clusters1[iC1].y);
+         float r2  = Sqrt(clusters2[iC2].x * clusters2[iC2].x + clusters2[iC2].y * clusters2[iC2].y);
+         fDoublets[iL][fNDoublets[iL]].tanLambda = (clusters1[iC1].z-clusters2[iC2].z)/(r1-r2);
+         ++fNDoublets[iL];
+       } else if( clusters2[iC2].phi - clusters1[iC1].phi > fPhiCut ) break;
+      
+      }
+
+    }
+
+    // 0 - 2Pi junction treatment (part II)
+    for ( int iC1 = fNClusters[iL]-1; iC1 > -1 ; --iC1 ) {
+      bool flag = true;
+
+      for ( int iC2 = 0; iC2 < fNClusters[iL+1] ; ++iC2 ) {
+
+       if( (TMath::TwoPi() - (clusters1[iC1].phi-clusters2[iC2].phi) ) < fPhiCut ) { 
+         fDoublets[iL].push_back(nPlets(iC1,iC2));
+         fDoublets[iL][fNDoublets[iL]].tanPhi = (clusters1[iC1].y-clusters2[iC2].y)/(clusters1[iC1].x-clusters2[iC2].x);
+         float r1  = Sqrt(clusters1[iC1].x * clusters1[iC1].x + clusters1[iC1].y * clusters1[iC1].y);
+         float r2  = Sqrt(clusters2[iC2].x * clusters2[iC2].x + clusters2[iC2].y * clusters2[iC2].y);
+         fDoublets[iL][fNDoublets[iL]].tanLambda = (clusters1[iC1].z-clusters2[iC2].z)/(r1-r2);
+         ++fNDoublets[iL];
+         flag = false;
+       } else break;
+
+      }
+
+      if (flag) break;
+    }
+  
+  }
+
+}
diff --git a/ITS/UPGRADE/AliITSUTrackerSA.h b/ITS/UPGRADE/AliITSUTrackerSA.h
new file mode 100755 (executable)
index 0000000..48834b1
--- /dev/null
@@ -0,0 +1,67 @@
+#ifndef ALIITSUTRACKERSA_H
+#define ALIITSUTRACKERSA_H
+
+//-------------------------------------------------------------------------
+//                   The stand-alone ITSU tracker
+//     It reads AliITSUClusterPix clusters and writes the tracks to the ESD
+//-------------------------------------------------------------------------
+
+#include "AliTracker.h"
+#include "AliITSUGeomTGeo.h"
+#include <TClonesArray.h>
+#include <vector>
+#include "AliITSUTrackerSAaux.h"   // Structs and other stuff 
+
+class TTree;
+class AliCluster;
+class AliESDEvent;
+
+using std::vector;
+
+//-------------------------------------------------------------------------
+class AliITSUTrackerSA : public AliTracker {
+public:
+  AliITSUTrackerSA();
+  virtual ~AliITSUTrackerSA() {} ;
+
+  // These functions must be implemented 
+  Int_t Clusters2Tracks(AliESDEvent *event);
+  Int_t PropagateBack(AliESDEvent *event);
+  Int_t RefitInward(AliESDEvent *event);
+  Int_t LoadClusters(TTree *ct);
+  void UnloadClusters();
+  AliCluster *GetCluster(Int_t index) const;
+
+  // Possibly, other public functions
+
+
+protected:
+  AliITSUTrackerSA(const AliITSUTrackerSA&);
+
+  void MakeDoublets();
+  void MakeTriplets();
+  void CASelection();
+  void GlobalFit();
+  void ChiSquareSelection();
+  // Other protected functions
+  // (Sorting, labeling, calculations of "roads", etc)
+
+private:
+  AliITSUTrackerSA &operator=(const AliITSUTrackerSA &tr);
+
+  // Data members
+  // Internal tracker arrays, layers, modules, etc
+  vector<itsCluster> fClusters[7];
+  TClonesArray fClustersTC[7];
+  vector<nPlets> fDoublets[6];
+  Int_t *fIndex[7];
+  Int_t fNClusters[7];
+  Int_t fNDoublets[6];
+  Float_t fPhiCut;
+  Float_t fRPhiCut;
+  Float_t fZCut;
+
+  ClassDef(AliITSUTrackerSA,1)   //ITSU stand-alone tracker
+};
+
+#endif
diff --git a/ITS/UPGRADE/AliITSUTrackerSAaux.h b/ITS/UPGRADE/AliITSUTrackerSAaux.h
new file mode 100755 (executable)
index 0000000..9f1bb2a
--- /dev/null
@@ -0,0 +1,36 @@
+#ifndef ALIITSUTRACKERSAAUX_H
+#define ALIITSUTRACKERSAAUX_H
+
+#include <vector>
+using std::vector;
+
+/* struct CompareAsc { // Adapted from TMath ROOT code */
+/* CompareAsc(Float_t *d,Float_t offset) : fData(d) {} */
+  
+/*   bool operator()(int i1, int i2) { */
+/*     return *(fData + i1) < *(fData + i2); */
+/*   } */
+  
+/*   Float_t fData; */
+/* }; */
+
+struct itsCluster {
+itsCluster():isUsed(false),x(0.f),y(0.f),z(0.f),varx(0.f),covxy(0.f),vary(0.f),phi(0.f),phiM(0.f) {}
+itsCluster(const float &X,const float &Y, const float &Z, const float &varX, const float &covXY, const float &varY,const float &Phi, const float &PhiM) : 
+  isUsed(false),x(X),y(Y),z(Z),varx(varX),covxy(covXY),vary(varY),phi(Phi),phiM(PhiM) {}
+  bool isUsed;
+  float x,y,z;            // Global coordinates
+  float varx,covxy,vary;  // Local covariance matrix
+  float phi,phiM;         // phi of the cluster and phi angle of the module containing the cluster
+};
+
+struct nPlets {
+nPlets() : id0(-1),id1(-1),id2(-1),level(0),tanPhi(),tanLambda(),neighbours() {}
+nPlets(int arg0,int arg1) : id0(arg0),id1(arg1),id2(-1),level(0),tanPhi(),tanLambda(),neighbours()  {}
+  int id0,id1,id2;
+  int level;
+  float tanPhi,tanLambda;
+  vector<int> neighbours;
+};
+
+#endif
index c08ce8e2a1d5c611b8884c4289d19dac38835845..406d49ad12b6a81dd7ce04f2d54693e7602c7d52 100644 (file)
@@ -18,6 +18,9 @@ using TMath::ATan2;
 using TMath::TwoPi;
 using TMath::BubbleLow;
 
+using std::cout;
+using std::endl;
+
 //////////////////////////////////////////////////////////////////////
 // This class is used to compute the position of all the primary    // 
 // vertices in a single event using the upgraded ITS.               //
index 89e7e25f53c3a5337bbd9b5bcd4898ca2791c5b9..b9628d97ea93bf32c7fb5b5fb345cc235a0e929c 100644 (file)
@@ -31,8 +31,8 @@ class AliITSUVertexer : public AliVertexer {
   UShort_t GetNumOfVertices() const { return fNoVertices; }
 
   // Setters
-  void SetPhiCut(const Double_t phicut) { fPhiCut=phicut; }
-  void SetZCut(const Double_t zcut)     { fZCut=zcut; }
+  void SetPhiCut(Double_t phicut) { fPhiCut=phicut; }
+  void SetZCut(Double_t zcut)     { fZCut=zcut; }
 
   #ifdef MC_CHECK
   // Debug + MC truth
index d8fa4c13ea891a7469ee06ed86205aa4d05def76..4ab4d274cd2dde05d65407b042ed0d8c1259b179 100644 (file)
@@ -91,7 +91,7 @@ AliITSUv0::AliITSUv0()
 }
 
 //______________________________________________________________________
-AliITSUv0::AliITSUv0(const char *title,const Int_t nlay)
+AliITSUv0::AliITSUv0(const char *title, Int_t nlay)
   :AliITSU(title,nlay)
   ,fNWrapVol(0)
   ,fWrapRMin(0)
@@ -490,10 +490,10 @@ void AliITSUv0::CreateMaterials() {
 }
 
 //______________________________________________________________________
-void AliITSUv0::DefineLayer(const Int_t nlay, const double phi0, const Double_t r,
-                           const Double_t zlen, const Int_t nstav,
-                           const Int_t nmod, const Double_t lthick,
-                           const Double_t dthick, const UInt_t dettypeID)
+void AliITSUv0::DefineLayer(Int_t nlay, double phi0, Double_t r,
+                           Double_t zlen, Int_t nstav,
+                           Int_t nmod, Double_t lthick,
+                           Double_t dthick, UInt_t dettypeID)
 {
   //     Sets the layer parameters
   // Inputs:
index 877c690feaaa691e3f015906ee9a1a3cc45cfc67..8064b1ad6996f558bd921791424b1bac046e142f 100644 (file)
@@ -38,7 +38,7 @@ class AliITSUv0 : public AliITSU {
   
 
   AliITSUv0();
-  AliITSUv0(const char *title, const Int_t nlay);
+  AliITSUv0(const char *title, Int_t nlay);
   virtual       ~AliITSUv0() ;
   virtual void   SetNWrapVolumes(Int_t n);
   virtual void   AddAlignableVolumes() const;
@@ -69,7 +69,7 @@ class AliITSUv0 : public AliITSU {
   AliITSUv0(const AliITSUv0 &source); // copy constructor
   AliITSUv0& operator=(const AliITSUv0 &source); // assignment operator
 
-  TGeoVolume* CreateWrapperVolume(const Int_t nLay);
+  TGeoVolume* CreateWrapperVolume(Int_t nLay);
 
   //
   Int_t     fNWrapVol;       // number of wrapper volumes
index 9c294f00d0ca0e9356daea604462638845a88442..e7b850454e1667e035a5aec78daf8621a8a1fbc9 100644 (file)
@@ -92,7 +92,7 @@ AliITSUv1::AliITSUv1()
 }
 
 //______________________________________________________________________
-AliITSUv1::AliITSUv1(const char *title,const Int_t nlay)
+AliITSUv1::AliITSUv1(const char *title, Int_t nlay)
   :AliITSU(title,nlay)
   ,fNWrapVol(0)
   ,fWrapRMin(0)
@@ -553,11 +553,11 @@ void AliITSUv1::CreateMaterials() {
 }
 
 //______________________________________________________________________
-void AliITSUv1::DefineLayer(const Int_t nlay, const double phi0, const Double_t r,
-                           const Double_t zlen, const Int_t nstav,
-                           const Int_t nunit, const Double_t lthick,
-                           const Double_t dthick, const UInt_t dettypeID,
-                           const Int_t buildLevel)
+void AliITSUv1::DefineLayer(Int_t nlay, double phi0, Double_t r,
+                           Double_t zlen, Int_t nstav,
+                           Int_t nunit, Double_t lthick,
+                           Double_t dthick, UInt_t dettypeID,
+                           Int_t buildLevel)
 {
   //     Sets the layer parameters
   // Inputs:
index 34331d1367bb7bd64a3c5503500d1c7bffb69ead..a257cfd7c0d8cea81db72002aef3c411e394e0a8 100644 (file)
@@ -40,7 +40,7 @@ class AliITSUv1 : public AliITSU {
   
 
   AliITSUv1();
-  AliITSUv1(const char *title, const Int_t nlay);
+  AliITSUv1(const char *title, Int_t nlay);
   virtual       ~AliITSUv1() ;
   virtual void   SetNWrapVolumes(Int_t n);
   virtual void   AddAlignableVolumes() const;
@@ -79,7 +79,7 @@ class AliITSUv1 : public AliITSU {
   AliITSUv1(const AliITSUv1 &source); // copy constructor
   AliITSUv1& operator=(const AliITSUv1 &source); // assignment operator
 
-  TGeoVolume* CreateWrapperVolume(const Int_t nLay);
+  TGeoVolume* CreateWrapperVolume(Int_t nLay);
 
   //
   Int_t     fNWrapVol;       // number of wrapper volumes
old mode 100644 (file)
new mode 100755 (executable)
index afdc633..012bd7b
@@ -37,6 +37,7 @@ set ( SRCS
     AliITSUClusterPix.cxx
     AliITSUSeed.cxx
     AliITSUTrackerGlo.cxx
+    AliITSUTrackerSA.cxx
     AliITSUTrackCond.cxx
     AliITSUTrackHyp.cxx
     AliITSUMatLUT.cxx
@@ -58,6 +59,8 @@ string ( REPLACE ".cxx" ".h" HDRS "${SRCS}" )
 
 set ( DHDR ITSUpgradeRecLinkDef.h)
 
+#set_source_files_properties( AliITSUTrackerSA.cxx PROPERTIES COMPILE_FLAGS "-O3 -ftree-vectorize -ffast-math -std=gnu++11" )
+
 set ( EINCLUDE TPC RAW ITS ITS/UPGRADE ITS/UPGRADE/v0 STEER/STEER STEER/ESD STEER/STEERBase)
 
 # set ( EXPORT AliITStrackV2.h AliITSVertexer.h AliITSRecoParam.h)
old mode 100644 (file)
new mode 100755 (executable)
index 917082f..6bb7fa3
@@ -23,6 +23,7 @@
 #pragma link C++ class AliITSUClusterPix+;
 #pragma link C++ class AliITSUSeed+;
 #pragma link C++ class AliITSUTrackerGlo+;
+#pragma link C++ class AliITSUTrackerSA+;
 #pragma link C++ class AliITSUTrackCond+;
 #pragma link C++ class AliITSUTrackHyp+;
 #pragma link C++ class AliITSUMatLUT+;
old mode 100644 (file)
new mode 100755 (executable)
index 768afbd..1af879a
@@ -200,6 +200,7 @@ Int_t AliITSUComparison
            Int_t lbl=t->GetLabel();
            if (lab==TMath::Abs(lbl)) {
              if (cnt==0) {esd=t; tlab=lbl;}
+              if (lbl> 0) {esd=t; tlab=lbl;}  
               cnt++;
            }
         }
index afd1490dbc445ce298ce4ce491a71ff4366d7c7d..5a8ff7e101e506b1deae8e095ce8e64963a96493 100644 (file)
@@ -245,6 +245,23 @@ void Config()
     gener->Init();
       
   }
+  else if (generatorFlag==3) {
+    
+    // Pure Pythia6 generator
+    AliGenPythia *generPy = new AliGenPythia(-1); 
+    generPy->SetMomentumRange(0,999999);
+    generPy->SetThetaRange(0., 180.);
+    generPy->SetYRange(-2.5,2.5);
+    generPy->SetPtRange(0,1000);
+    generPy->SetProcess(kPyMb);
+    generPy->SetEnergyCMS(14000.);
+    generPy->SetProjectile("p", 1, 1) ; 
+    generPy->SetTarget("p", 1, 1) ; 
+    generPy->SetSigma(50e-4, 50e-4, 5.0);   //Sigma in (X,Y,Z) (cm) on IP position
+    generPy->SetVertexSmear(kPerEvent);
+    generPy->Init();
+    //
+  }
   // 
   
 
index cf62443509cbcd89eaf7ab1f12fd0bc06b45ccd9..9f08816e79200d0eb7b86542d7cf10dfe592f76b 100644 (file)
@@ -191,7 +191,7 @@ void DetectorK::AddLayer(char *name, Float_t radius, Float_t radL, Float_t phiRe
     if (!(newLayer->isDead)) {
       fNumberOfActiveLayers += 1;
       TString lname(newLayer->GetName());
-      if (!lname.Contains("tpc")) fNumberOfActiveITSLayers += 1;
+      if ( IsITSLayer(lname) ) fNumberOfActiveITSLayers += 1;
     }
 
 
@@ -217,7 +217,7 @@ void DetectorK::KillLayer(char *name) {
        tmp->isDead = kTRUE;
        fNumberOfActiveLayers -= 1; 
        TString lname(tmp->GetName());
-       if (!lname.Contains("tpc")) fNumberOfActiveITSLayers -= 1;
+       if ( IsITSLayer(lname) ) fNumberOfActiveITSLayers -= 1;
      }     
   }
 }
@@ -305,13 +305,13 @@ void DetectorK::SetResolution(char *name, Float_t phiRes, Float_t zRes) {
       tmp->isDead = kTRUE;
       if (!wasDead) {
        fNumberOfActiveLayers -= 1;
-       if (!lname.Contains("tpc")) fNumberOfActiveITSLayers -= 1;
+       if ( IsITSLayer(lname) ) fNumberOfActiveITSLayers -= 1;
       }
     } else {
       tmp->isDead = kFALSE;
       if (wasDead) {
        fNumberOfActiveLayers += 1;
-       if (!lname.Contains("tpc")) fNumberOfActiveITSLayers += 1;
+       if ( IsITSLayer(lname) ) fNumberOfActiveITSLayers += 1;
       }
     }
 
@@ -380,14 +380,14 @@ void DetectorK::RemoveLayer(char *name) {
     if (!wasDead) {
       fNumberOfActiveLayers -= 1;
       TString lname(tmp->GetName());
-      if (!lname.Contains("tpc")) fNumberOfActiveITSLayers -= 1;
+      if ( IsITSLayer(lname) ) fNumberOfActiveITSLayers -= 1;
       
     }
   }
 }
 
 
-void DetectorK::PrintLayout() {
+void DetectorK::PrintLayout(Bool_t full) {
   //
   // Prints the detector layout
   //
@@ -403,7 +403,7 @@ void DetectorK::PrintLayout() {
   
     // don't print all the tpc layers
     TString name(tmp->GetName());
-    if (name.Contains("tpc") && (!name.Contains("tpc_0")) ) continue;
+    if (!full && !IsITSLayer(name) && !name.Contains("_0")) continue;
 
     printf("%d. %s \t %03.2f   \t%1.4f\t  ",i,
           tmp->GetName(), tmp->radius, tmp->radL);
@@ -457,6 +457,7 @@ void DetectorK::PlotLayout(Int_t plotDead) {
     TString name(tmp->GetName());
     if (!tmp->isDead) layEl->SetLineWidth(2);
     if (name.Contains("tpc") )  layEl->SetLineColor(29);
+    if (name.Contains("trd") )  layEl->SetLineColor(30);
 
     if (!tmp->isDead || plotDead) layEl->Draw();
   
@@ -473,8 +474,8 @@ void DetectorK::AddTPC(Float_t phiResMean, Float_t zResMean, Int_t skip) {
   // skip=1: Use every padrow, skip=2: Signal in every 2nd padrow 
 
 
-  AddLayer((char*)"IFC",   77.8,0.01367); // Inner Field cage
-  AddLayer((char*)"OFC",   254.0,0.01367); // Outer Field cage
+  AddLayer((char*)"tpcIFC",   77.8,0.01367); // Inner Field cage
+  AddLayer((char*)"tpcOFC",   254.0,0.01367); // Outer Field cage
 
   // % Radiation Lengths ... Average per TPC row  (i.e. total/159 )
   const int kNPassiveBound = 2;
@@ -522,6 +523,16 @@ void DetectorK::AddTPC(Float_t phiResMean, Float_t zResMean, Int_t skip) {
  
 }
 
+void DetectorK::AddTRD(Float_t phiResMean, Float_t zResMean, Float_t lrEff) {
+  //
+  // Emulates the TRD
+  // 
+  const double trdX2X0=3.3e-2;
+  for (int i=0;i<6;i++) AddLayer((char*)Form("trd_%d",i), 300.0+13*i ,trdX2X0, phiResMean, zResMean,
+                                lrEff<1 ? lrEff : 1.0); 
+}
+
 void DetectorK::RemoveTPC() {
 
   // flag as dead, although resolution is ok ... makes live easier in the prints ... ;-)
@@ -531,7 +542,6 @@ void DetectorK::RemoveTPC() {
     TString name(tmp->GetName());
     if (name.Contains("tpc")) { RemoveLayer((char*)name.Data()); i--; }
   }
-  RemoveLayer((char*)"IFC");
   
 }
 
@@ -805,6 +815,8 @@ void DetectorK::SolveViaBilloir(Int_t flagD0,Int_t print, Bool_t allPt, Double_t
 
   Int_t komb = (Int_t) TMath::Power(base,nLayer);
 
+  printf("N ITS Layers: %d\n",fNumberOfActiveITSLayers);
+
   TMatrixD probLay(base,fNumberOfActiveITSLayers);
   TMatrixD probKomb(komb,nLayer);
   for (Int_t num=0; num<komb; num++) {
@@ -1052,13 +1064,13 @@ void DetectorK::SolveViaBilloir(Int_t flagD0,Int_t print, Bool_t allPt, Double_t
              layerEfficiency =  ProbGoodChiSqPlusConfHit( radius*100,leff, rphiError , zError  ) ;
              
            TString name(layer->GetName());
-           if (!name.Contains("tpc")) {
+           if ( IsITSLayer(name) ) {
              probLay(2,iLayActive)= layerEfficiency ; // Pcorr
              probLay(0,iLayActive)= ProbNullChiSqPlusConfHit( radius*100,leff, rphiError , zError  ) ; // Pnull
              probLay(1,iLayActive)= 1 - probLay(2,iLayActive) - probLay(0,iLayActive);                 // Pfake
              iLayActive++;    
            }
-           if (name.Contains("tpc") && (!name.Contains("tpc_0")) ) continue;
+           if (!IsITSLayer(name) && (!name.Contains("tpc_0")) ) continue;
 
            if (print == 1 && fTransMomenta[i] >= meanPt && massloop == 2 && printOnce == 1) 
            {
@@ -1073,7 +1085,7 @@ void DetectorK::SolveViaBilloir(Int_t flagD0,Int_t print, Bool_t allPt, Double_t
                printf("        -  \n");
            }
            
-           if (!name.Contains("tpc") && !name.Contains("trd"))   fEfficiency[massloop][i] *= layerEfficiency;
+           if (IsITSLayer(name))   fEfficiency[massloop][i] *= layerEfficiency;
            
            
        }
@@ -1247,7 +1259,7 @@ void DetectorK::SolveViaBilloir(Int_t flagD0,Int_t print, Bool_t allPt, Double_t
            layer = (CylLayerK*)fLayers.At(j);
            
            TString name(layer->GetName());
-           if ( (name.Contains("tpc") && (!name.Contains("tpc_0"))) || layer->isDead) continue;
+           if ( layer->isDead || ( !IsITSLayer(name) && (!name.Contains("tpc_0"))) ) continue;
            
            if (print == 1 && fTransMomenta[i] >= meanPt && massloop == 2 && printOnce == 1) 
            {
@@ -1276,7 +1288,7 @@ void DetectorK::SolveViaBilloir(Int_t flagD0,Int_t print, Bool_t allPt, Double_t
                     detPointResBwd[j][i]*1.e6, detPointZResBwd[j][i]*1.e6,
                     phiRes*1.e6, zRes*1.e6,
                     HitDensity(radius*100)) ;
-             if (!name.Contains("tpc")) 
+             if (IsITSLayer(name)) 
                printf("%10.3f\n", layerEfficiency);
              else
                printf("        -  \n");                      
@@ -1316,13 +1328,13 @@ void DetectorK::SolveViaBilloir(Int_t flagD0,Int_t print, Bool_t allPt, Double_t
              layerEfficiency =  ProbGoodChiSqPlusConfHit( radius*100,leff, rphiError , zError  ) ;
              
            TString name(layer->GetName());
-           if (!name.Contains("tpc")) {
+           if (IsITSLayer(name)) {
              probLay(2,iLayActive)= layerEfficiency ; // Pcorr
              probLay(0,iLayActive)= ProbNullChiSqPlusConfHit( radius*100,leff, rphiError , zError  ) ; // Pnull
              probLay(1,iLayActive)= 1 - probLay(2,iLayActive) - probLay(0,iLayActive);                 // Pfake
              iLayActive++;    
            }
-           if (name.Contains("tpc") && (!name.Contains("tpc_0")) ) continue;
+           if (!IsITSLayer(name) && (!name.Contains("tpc_0")) ) continue;
 
            if (print == 1 && fTransMomenta[i] >= meanPt && massloop == 2 && printOnce == 1) 
            {
@@ -1331,7 +1343,7 @@ void DetectorK::SolveViaBilloir(Int_t flagD0,Int_t print, Bool_t allPt, Double_t
                     fDetPointRes[j][i]*1.e6, fDetPointZRes[j][i]*1.e6,
                     phiRes*1.e6, zRes*1.e6,
                     HitDensity(radius*100)) ;
-             if (!name.Contains("tpc")) 
+             if (IsITSLayer(name)) 
                printf("%10.3f\n", layerEfficiency);
              else
                printf("        -  \n");
@@ -1341,7 +1353,7 @@ void DetectorK::SolveViaBilloir(Int_t flagD0,Int_t print, Bool_t allPt, Double_t
              fEfficProlongLay[i] = layerEfficiency;
            }
 
-           if (!name.Contains("tpc") && !name.Contains("trd"))   fEfficiency[massloop][i] *= layerEfficiency;
+           if (IsITSLayer(name))   fEfficiency[massloop][i] *= layerEfficiency;
 
 
 
@@ -2292,3 +2304,10 @@ Bool_t DetectorK::PropagateToR(AliExternalTrackParam* trc, double r, double b, i
   return kTRUE;
 }
 
+
+//_________________________________________
+Bool_t DetectorK::IsITSLayer(const TString &lname)
+{
+  // return true for ITS layers
+  return !(lname.Contains("tpc") || lname.Contains("trd"));
+}
index f95ceba12791bbc1bf7706e024a02cb501279556..75b5e4c0a922e2f90c1696278f76c2473962e947 100644 (file)
@@ -72,12 +72,13 @@ class DetectorK : public TNamed {
   Float_t GetResolution(char *name, Int_t axis=0);
   Float_t GetLayerEfficiency(char *name);
 
-  void PrintLayout(); 
+  void PrintLayout(Bool_t full = kFALSE); 
   void PlotLayout(Int_t plotDead = kTRUE);
   
   void MakeAliceAllNew(Bool_t flagTPC =1,Bool_t flagMon=1);
   void MakeAliceCurrent(Int_t AlignResiduals = 0, Bool_t flagTPC =1);
-  void AddTPC(Float_t phiResMean, Float_t zResMean, Int_t skip=1);
+  void AddTPC(Float_t phiResMean=0.1, Float_t zResMean=0.1, Int_t skip=1);
+  void AddTRD(Float_t phiResMean=0.02, Float_t zResMean=2.5, Float_t lrEff=0.9);
   void RemoveTPC();
 
   void SetBField(Float_t bfield) {fBField = bfield; }
@@ -156,6 +157,8 @@ class DetectorK : public TNamed {
   static Bool_t PropagateToR(AliExternalTrackParam* trc, double r, double b, int dir=0);
   Double_t* PrepareEffFakeKombinations(TMatrixD *probKomb, TMatrixD *probLay);
 
+  Bool_t IsITSLayer(const TString& lname);
+
  protected:
  
   Int_t fNumberOfLayers;        // total number of layers in the model
index e91c370015bb524d7303a9ac4b1963a704dfcf53..83e743bcc384ce73a1424e3e8a13be0e6f795b13 100644 (file)
@@ -4,7 +4,6 @@
 
 //void standardPlots() {
 
-
 void testDetectorUp() {
 
 
@@ -53,10 +52,11 @@ void testDetectorUp() {
   its.MakeStandardPlots(0,2,1,kTRUE);
   //  return;
   its.AddTPC(0.1,0.1);
+  //  its.AddTRD(0.02,2.5);
   its.SolveViaBilloir(0);
  
   its.MakeStandardPlots(1,1,1,kTRUE);
-
+  //  its.PrintLayout(1);
 }
 
 void testDetectorCurr() {
index e6639177642a62d682f8950e21bd61168fe519a9..8173f51041f1c3a62c4f2234669ba11073332811 100644 (file)
@@ -1901,12 +1901,9 @@ Int_t  AliAnalysisTaskJetCluster::GetListOfTracks(TList *list,Int_t type){
          if (trPt <= 20. && (ntpcClus < NTPCClsCut.Eval(trPt))) continue;
          else if (trPt > 20. && ntpcClus < 100) continue;
 
-         Int_t idtr1 = tr->GetID(); 
-         Bool_t flagSame = kFALSE;
-         AvoidDoubleCountingHF(aod, idtr1, flagSame);
-         if (flagSame) continue; 
+         if (AvoidDoubleCountingHF(aod,tr)) continue;
        }
-       // 
+       //
 
         if(fRequireITSRefit){if((tr->GetStatus()&AliESDtrack::kITSrefit)==0)continue;}
         if (fApplySharedClusterCut) {
@@ -2109,23 +2106,25 @@ Int_t AliAnalysisTaskJetCluster::AddDaughters(TList * list, AliAODMCParticle *pa
        }                       
 return count;  
 }
-void AliAnalysisTaskJetCluster::AvoidDoubleCountingHF(AliAODEvent *aod, Int_t idtr1,  Bool_t &fFlagSameTr){
+
+
+Bool_t AliAnalysisTaskJetCluster::AvoidDoubleCountingHF(AliAODEvent *aod, AliAODTrack *tr1){
   
-       Bool_t sametr = kFALSE;
+  if(!(tr1->TestFilterBit(BIT(9)))) return kFALSE;
 
-     for(int jt = 0;jt < aod->GetNumberOfTracks();++jt){
+  Int_t idtr1 = tr1->GetID();
 
-       AliAODTrack *tr2 = aod->GetTrack(jt);
-       Int_t idtr2 = tr2->GetID();
-       if (idtr2>-1) continue;
+  for(int jt = 0;jt < aod->GetNumberOfTracks();++jt){
 
-       idtr2=-1*idtr2;
-       if (idtr1==idtr2-1) sametr = kTRUE;
+    const AliAODTrack *tr2 = aod->GetTrack(jt);
+    Int_t idtr2 = tr2->GetID();
+       
+    if (!(tr2->TestFilterBit(BIT(4)))) continue;
+    if (idtr1==(idtr2+1)*-1.) return kTRUE;
        
-     }
-     fFlagSameTr = sametr;
+  }
+  return kFALSE;
 }
-
 void AliAnalysisTaskJetCluster::LoadTrPtResolutionRootFileFromOADB() {
 
    if (!gGrid) {
index 8424bd5b5ce068c107e1ce53650132bde1ed5a75..042de7309c020801960244a6f13a7ed053cb17a4 100644 (file)
@@ -27,6 +27,7 @@ namespace fastjet {
 class AliJetHeader;
 class AliESDEvent;
 class AliAODEvent;
+class AliAODTrack;
 class AliAODExtension;
 class AliAODJet;
 class AliGenPythiaEventHeader;
@@ -158,7 +159,7 @@ class AliAnalysisTaskJetCluster : public AliAnalysisTaskSE
 
     Int_t GetListOfTracks(TList *list,Int_t type);
        Int_t AddDaughters(TList * list, AliAODMCParticle *part, TClonesArray * tca);
-    void AvoidDoubleCountingHF(AliAODEvent *aod, Int_t idtr1, Bool_t &fFlagSameTr);
+    Bool_t AvoidDoubleCountingHF(AliAODEvent *aod, AliAODTrack *tr1);
        
     AliAODEvent     *fAOD;                // ! where we take the jets from can be input or output AOD
     AliAODExtension *fAODExtension;       // ! AOD extension in case we write a non-sdt branch to a separate file and the aod is standard
index 8836898499e136fa39f4ce50ea1409ec5226aedc..dc94ff38be92d5638a3d87ce464fc21b16660ea4 100644 (file)
@@ -48,7 +48,7 @@ class AliJetFillCalTrkEvent
   virtual AliJetCalTrkEvent* GetCalTrkEvent() const {return fCalTrkEvent;}
 
   // Other
-  virtual void          Exec(Option_t const * /*option*/) {;}
+  virtual void          Exec(const Option_t  */*option*/) {;}
   virtual Float_t       EtaToTheta(Float_t arg);
 
  protected:
index 66c0e9f5263da43377a9b8ae56eee331f8caec06..abce117eba0a7ad021f6b47b8cd79a54c2b559c8 100644 (file)
@@ -208,8 +208,10 @@ Bool_t AliMFTAnalysisTools::CalculatePCA(AliAODDimuon *dimuon, Double_t *pca, Do
   TObjArray *muons = new TObjArray();
   muons -> Add(dimuon->GetMu(0));
   muons -> Add(dimuon->GetMu(1));
-
-  return CalculatePCA(muons, pca, pcaQuality, kinem);
+  
+  Bool_t result = CalculatePCA(muons, pca, pcaQuality, kinem);
+  delete muons;
+  return result;
 
 }
 
@@ -224,15 +226,18 @@ Bool_t AliMFTAnalysisTools::CalculatePCA(TObjArray *muons, Double_t *pca, Double
   }
   
   Double_t fXPointOfClosestApproach=0, fYPointOfClosestApproach=0, fZPointOfClosestApproach=0;
-  
-  AliAODTrack *muon[nMuons];
-  AliMUONTrackParam *param[nMuons];
+
+  AliAODTrack *muon[AliMFTConstants::fNMaxMuonsForPCA]        = {0};
+  AliMUONTrackParam *param[AliMFTConstants::fNMaxMuonsForPCA] = {0};
 
   // Finding AliMUONTrackParam objects for each muon
   
   for (Int_t iMu=0; iMu<nMuons; iMu++) {
     muon[iMu] = (AliAODTrack*) muons->At(iMu);
-    if (TMath::Abs(muon[iMu]->Pz())<1.e-6) return kFALSE;
+    if (TMath::Abs(muon[iMu]->Pz())<1.e-6) {
+      for(Int_t i=0;i<iMu;i++) delete param[i];
+      return kFALSE;
+    }
     param[iMu] = new AliMUONTrackParam();
     param[iMu] -> SetNonBendingCoor(muon[iMu]->XAtDCA());
     param[iMu] -> SetBendingCoor(muon[iMu]->YAtDCA());
@@ -241,35 +246,38 @@ Bool_t AliMFTAnalysisTools::CalculatePCA(TObjArray *muons, Double_t *pca, Double
     param[iMu] -> SetBendingSlope(muon[iMu]->Py()/muon[iMu]->Pz());
     param[iMu] -> SetInverseBendingMomentum( muon[iMu]->Charge() * (1./muon[iMu]->Pz()) / (TMath::Sqrt(1+TMath::Power(muon[iMu]->Py()/muon[iMu]->Pz(),2))) );
   }
-
+  
   // here we want to understand in which direction we have to search the minimum...
   
   Double_t step = 1.;  // initial step, in cm
   Double_t startPoint = 0.;
-
+  
   Double_t r[3]={0}, z[3]={startPoint, startPoint+step, startPoint+2*step};
   
-  TVector3 **points = new TVector3*[nMuons];
+  TVector3 **points = new TVector3*[AliMFTConstants::fNMaxMuonsForPCA];
   
   for (Int_t i=0; i<3; i++) {
     for (Int_t iMu=0; iMu<nMuons; iMu++) {
       AliMUONTrackExtrap::ExtrapToZ(param[iMu], z[i]);
       points[iMu] = new TVector3(param[iMu]->GetNonBendingCoor(),param[iMu]->GetBendingCoor(),z[i]);
-    }
+               }
     r[i] = GetDistanceBetweenPoints(points,nMuons);
+    for (Int_t iMu=0; iMu<nMuons; iMu++) delete points[iMu]; 
   }
-
+  
   Int_t researchDirection = 0;
   
   if      (r[0]>r[1] && r[1]>r[2]) researchDirection = +1;   // towards z positive
   else if (r[0]<r[1] && r[1]<r[2]) researchDirection = -1;   // towards z negative
   else if (r[0]<r[1] && r[1]>r[2]) {
     printf("E-AliMFTAnalysisTools::CalculatePCA: Point of closest approach cannot be found for dimuon (no minima)\n");
+    for (Int_t iMu=0;iMu<nMuons;iMu++) delete param[iMu];
+    delete points;
     return kFALSE;
-  }
-
+  }    
+  
   while (TMath::Abs(researchDirection)>0.5) {
-
+      
     if (researchDirection>0) {
       z[0] = z[1];
       z[1] = z[2];
@@ -282,24 +290,25 @@ Bool_t AliMFTAnalysisTools::CalculatePCA(TObjArray *muons, Double_t *pca, Double
     }
     if (TMath::Abs(z[0])>900.) {
       printf("E-AliMFTAnalysisTools::CalculatePCA: Point of closest approach cannot be found for dimuon (no minima in the fiducial region)\n");
+      for (Int_t iMu=0;iMu<nMuons;iMu++) delete param[iMu];
+      delete points;
       return kFALSE;
     }
     
-    for (Int_t iMu=0; iMu<nMuons; iMu++) delete points[iMu];
-    
     for (Int_t i=0; i<3; i++) {
       for (Int_t iMu=0; iMu<nMuons; iMu++) {
-        AliMUONTrackExtrap::ExtrapToZ(param[iMu], z[i]);
-        points[iMu] = new TVector3(param[iMu]->GetNonBendingCoor(),param[iMu]->GetBendingCoor(),z[i]);
+       AliMUONTrackExtrap::ExtrapToZ(param[iMu], z[i]);
+       points[iMu] = new TVector3(param[iMu]->GetNonBendingCoor(),param[iMu]->GetBendingCoor(),z[i]);
       }      
       r[i] = GetDistanceBetweenPoints(points,nMuons);
+      for (Int_t iMu=0;iMu<nMuons;iMu++) delete points[iMu];
     }
     researchDirection=0;
     if      (r[0]>r[1] && r[1]>r[2]) researchDirection = +1;   // towards z positive
     else if (r[0]<r[1] && r[1]<r[2]) researchDirection = -1;   // towards z negative
-
+    
   }
-
+  
   // now we now that the minimum is between z[0] and z[2] and we search for it
   
   step *= 0.5;
@@ -308,18 +317,17 @@ Bool_t AliMFTAnalysisTools::CalculatePCA(TObjArray *muons, Double_t *pca, Double
     z[2] = z[1]+step;
     for (Int_t i=0; i<3; i++) {
       for (Int_t iMu=0; iMu<nMuons; iMu++) {
-        AliMUONTrackExtrap::ExtrapToZ(param[iMu], z[i]);
-        points[iMu] = new TVector3(param[iMu]->GetNonBendingCoor(),param[iMu]->GetBendingCoor(),z[i]);
+       AliMUONTrackExtrap::ExtrapToZ(param[iMu], z[i]);
+       points[iMu] = new TVector3(param[iMu]->GetNonBendingCoor(),param[iMu]->GetBendingCoor(),z[i]);
       }      
       r[i] = GetDistanceBetweenPoints(points,nMuons);
+      for (Int_t iMu=0;iMu<nMuons;iMu++)       delete points[iMu];
     }
     if      (r[0]<r[1]) z[1] = z[0];
     else if (r[2]<r[1]) z[1] = z[2];
     else step *= 0.5;
   }
   
-  delete [] points;
-
   // Once z of minimum is found, we evaluate the x and y coordinates by averaging over the contributing tracks
   
   fZPointOfClosestApproach = z[1];
@@ -338,7 +346,7 @@ Bool_t AliMFTAnalysisTools::CalculatePCA(TObjArray *muons, Double_t *pca, Double
   pca[2] = fZPointOfClosestApproach;
   
   // Evaluating the kinematics of the N-muon
-
+  
   Double_t pTot[3] = {0};
   Double_t ene = 0.;
   Double_t massMu = TDatabasePDG::Instance()->GetParticle("mu-")->Mass();
@@ -350,9 +358,9 @@ Bool_t AliMFTAnalysisTools::CalculatePCA(TObjArray *muons, Double_t *pca, Double
   }
   
   kinem.SetPxPyPzE(pTot[0], pTot[1], pTot[2], ene);
-
+  
   // Evaluating the PCA quality of the N-muon
-
+  
   Double_t sum=0.,squareSum=0.;
   for (Int_t iMu=0; iMu<nMuons; iMu++) {
     Double_t wOffset = AliMFTAnalysisTools::GetAODMuonWeightedOffset(muon[iMu],fXPointOfClosestApproach, fYPointOfClosestApproach, fZPointOfClosestApproach);
@@ -362,7 +370,9 @@ Bool_t AliMFTAnalysisTools::CalculatePCA(TObjArray *muons, Double_t *pca, Double
   }
   if (sum > 0.) pcaQuality =  (sum-squareSum/sum) / (nMuons-1);
   else pcaQuality = 0.;
-
+  
+  for(Int_t iMu=0;iMu<nMuons;iMu++) delete param[iMu];
+  delete points;
   return kTRUE;
   
 }
index c195ff16dee14a38c5328157be738ad83a595f30..422bb9c1a43fd9c527fb8351525ddee523e3b1f6 100644 (file)
@@ -336,7 +336,7 @@ Int_t AliMFTTrackerMU::Clusters2Tracks(AliESDEvent *event) {
       myESDTrack -> SetFirstTrackingPoint(newTrack->GetMFTCluster(0)->GetX(), newTrack->GetMFTCluster(0)->GetY(), newTrack->GetMFTCluster(0)->GetZ());
       myESDTrack -> SetXYAtVertex(newTrack->GetOffsetX(0., AliMFTConstants::fZEvalKinem), newTrack->GetOffsetY(0., AliMFTConstants::fZEvalKinem));
       myESDTrack -> SetRAtAbsorberEnd(newTrack->GetRAtAbsorberEnd());
-      //      myESDTrack -> SetCovariances(newTrack->GetTrackParamAtMFTCluster(0)->GetCovariances());    // waiting for commit from Peter...
+      myESDTrack -> SetCovariances(newTrack->GetTrackParamAtMFTCluster(0)->GetCovariances());
       myESDTrack -> SetChi2MatchTrigger(esdTrack->GetChi2MatchTrigger());
       myESDTrack -> SetMuonClusterMap(esdTrack->GetMuonClusterMap());
       myESDTrack -> SetHitsPatternInTrigCh(esdTrack->GetHitsPatternInTrigCh());
@@ -347,7 +347,7 @@ Int_t AliMFTTrackerMU::Clusters2Tracks(AliESDEvent *event) {
       for (Int_t iCluster=0; iCluster<newTrack->GetNMFTClusters(); iCluster++) {
        AliMFTCluster *localCluster = newTrack->GetMFTCluster(iCluster);
        mftClusterPattern |= 1 << localCluster->GetPlane();
-       mftClusterPattern |= IsCorrectMatch(localCluster, newTrack->GetMCLabel()) << fNMaxPlanes+localCluster->GetPlane();
+       mftClusterPattern |= IsCorrectMatch(localCluster, newTrack->GetMCLabel()) << (fNMaxPlanes + localCluster->GetPlane());
       }
       myESDTrack -> SetMFTClusterPattern(mftClusterPattern);
       
index ed16f9cb6fe6f310c874f0e5e9eed301e231eaca..cb4482cadf5b558c0166bac0d4ec3d9ec8e8649c 100644 (file)
@@ -31,7 +31,7 @@ string ( REPLACE ".cxx" ".h" HDRS "${SRCS}" )
 
 set ( DHDR MFTbaseLinkDef.h)
 
-set ( EINCLUDE  STRUCT RAW MUON STEER/STEER STEER/STEERBase)
+set ( EINCLUDE  STRUCT RAW MUON STEER/STEER STEER/AOD STEER/STEERBase)
 
 set ( EXPORT AliMFTAnalysisTools.h AliMFTConstants.h)
 
index 7dcfeec12407d7d5f20e7fbfc89ca447621eb477..efef57658b6bd579c10edb985f2264bfaf654f0f 100644 (file)
@@ -38,5 +38,5 @@ endif(ALICE_TARGET MATCHES "macosx")
 
 set ( EINCLUDE MICROCERN MICROCERN/kerngen)
 
-set ( PACKFFLAGS  "${FFLAGS} -IMICROCERN/kerngen")
+set ( PACKFFLAGS  "${FFLAGS} -I${CMAKE_SOURCE_DIR}/MICROCERN/kerngen")
 
index 3f037b1565e634714736fbdb30e890fe601fbcda..ad00c3c3a9a6904d1b73b87ed8bee18e301777d3 100644 (file)
@@ -6,7 +6,19 @@
 cmake_minimum_required(VERSION 2.8.4 FATAL_ERROR)
 
 # This will only build MONITOR only if ZeroMQ is found
+set (PACKAGES
+  CMakebinalitestproc.pkg
+  CMakebinderoot.pkg
+  CMakebinmonitorCheck.pkg
+  CMakebinmonitorGDC.pkg
+  CMakelibMONITOR.pkg
+)
+
 if(ZEROMQ_FOUND)
-file(GLOB PACKAGES CMake*.pkg)
-ALICE_BuildModule()
+set(PACKAGES "${PACKAGES}"
+  CMakelibMONITORzmq.pkg
+  CMakebinalieventserver.pkg
+)
 ENDIF(ZEROMQ_FOUND)
+
+ALICE_BuildModule()
index c71d78acd0e56f2085e329d75da52c9ed0f7ae08..16185de51c2024f3cdcac546f82294c993726c12 100644 (file)
@@ -70,7 +70,7 @@ list(APPEND SRCS ${GFILES})
 set ( SHLIBS  ${BINLIBDIRS} EVGEN -lEGPythia6 Pythia6 -lpythia6 AliPythia6 lhapdf THijing hijing THerwig herwig TPHIC FASTSIM microcern)
 
 set ( EINCLUDE STEER/STEER )
-set ( ELIBS ${ELIBS} MONITOR )
+set ( ELIBS ${ELIBS} MONITOR MONITORzmq )
 
 
 set ( DATE_ROOT $ENV{DATE_ROOT})
index 5884f6af6defc6fab27867874727538f276dbdb9..e3067b81767907133ea0bb0892fd7ba7c6aa7942 100644 (file)
@@ -33,9 +33,6 @@ set ( SRCS
     AliDimIntNotifier.cxx 
     AliChildProcTerminator.cxx
     AliEventServerPreferencesWindow.cxx
-    AliEventServerWindow.cxx
-    AliRecoServerThread.cxx
-    AliRecoServer.cxx
     AliTestChildProc.cxx 
     )
 
@@ -45,7 +42,7 @@ string ( REPLACE ".cxx" ".h" HDRS "${SRCS}" )
 
 set ( DHDR  MONITORLinkDef.h)
 
-set ( EINCLUDE  TPC TPC/Rec ITS RAW STEER/STEER STEER/CDB STEER/STEERBase ZEROMQ_INCLUDE_DIR)
+set ( EINCLUDE  TPC TPC/Rec ITS RAW STEER/STEER STEER/CDB STEER/STEERBase)
 
 set(DIMDIR $ENV{DIMDIR})
 set(ODIR $ENV{ODIR})
@@ -62,7 +59,7 @@ if(DIMDIR)
   set ( CXXFLAGS  "-DALI_DIM ${CXXFLAGS}")
 endif(DIMDIR)
 
-set ( ELIBS ${ELIBS} ${ZEROMQ_LIBRARY} )
+set ( ELIBS ${ELIBS} )
 
 # this must be set in a better way
 set ( ELIBSDIR ${ELIBSDIR}  /usr/lib64)
diff --git a/MONITOR/CMakelibMONITORzmq.pkg b/MONITOR/CMakelibMONITORzmq.pkg
new file mode 100644 (file)
index 0000000..d2b9856
--- /dev/null
@@ -0,0 +1,61 @@
+# -*- mode: CMake -*- 
+#--------------------------------------------------------------------------------#
+# Package File for MONITOR                                                       #
+# Author : Johny Jose (johny.jose@cern.ch)                                       #
+# Variables Defined :                                                            #
+#                                                                                #
+# SRCS - C++ source files                                                        #
+# HDRS - C++ header files                                                        #
+# DHDR - ROOT Dictionary Linkdef header file                                     #
+# CSRCS - C source files                                                         #
+# CHDRS - C header files                                                         #
+# EINCLUDE - Include directories                                                 #
+# EDEFINE - Compiler definitions                                                 #
+# ELIBS - Extra libraries to link                                                #
+# ELIBSDIR - Extra library directories                                           #
+# PACKFFLAGS - Fortran compiler flags for package                                #
+# PACKCXXFLAGS - C++ compiler flags for package                                  #
+# PACKCFLAGS - C compiler flags for package                                      #
+# PACKSOFLAGS - Shared library linking flags                                     #
+# PACKLDFLAGS - Module linker flags                                              #
+# PACKBLIBS - Libraries to link (Executables only)                               #
+# EXPORT - Header files to be exported                                           #
+# CINTHDRS - Dictionary header files                                             #
+# CINTAUTOLINK - Set automatic dictionary generation                             #
+# ARLIBS - Archive Libraries and objects for linking (Executables only)          #
+# SHLIBS - Shared Libraries and objects for linking (Executables only)           #
+#--------------------------------------------------------------------------------#
+
+set ( SRCS   
+    AliEventServerWindow.cxx
+    AliRecoServerThread.cxx
+    AliRecoServer.cxx
+    )
+
+string ( REPLACE ".cxx" ".h" CINTHDRS "${SRCS}" )
+
+string ( REPLACE ".cxx" ".h" HDRS "${SRCS}" )
+
+set ( DHDR  MONITORzmqLinkDef.h)
+
+set ( EINCLUDE  STEER/STEERBase "${ZEROMQ_INCLUDE_DIR}")
+
+set(DIMDIR $ENV{DIMDIR})
+set(ODIR $ENV{ODIR})
+
+if(DIMDIR)
+  set ( SRCS ${SRCS}  SORNotifier.cxx)
+  set ( EINCLUDE ${EINCLUDE}  ${DIMDIR}/dim)
+  set ( ELIBS  dim)
+  set ( ELIBSDIR  ${DIMDIR}/${ODIR})
+  if(ELIBSDIR STREQUAL "${DIMDIR}/")
+    set (ELIBSDIR ${DIMDIR}/linux)
+  endif(ELIBSDIR STREQUAL "${DIMDIR}/")
+
+  set ( CXXFLAGS  "-DALI_DIM ${CXXFLAGS}")
+endif(DIMDIR)
+
+set ( ELIBS ${ELIBS} ${ZEROMQ_LIBRARY} )
+
+# this must be set in a better way
+set ( ELIBSDIR ${ELIBSDIR}  /usr/lib64)
index b585de9276d0b76827584b9304647a9cff3e4c4b..ee26e77fd0ad895f3df699a670d155380ecd881b 100644 (file)
@@ -10,9 +10,6 @@
 #pragma link off all functions;
 
 #pragma link C++ class AliEventServerPreferencesWindow+;
-#pragma link C++ class AliEventServerWindow+;
-#pragma link C++ class AliRecoServerThread+;
-#pragma link C++ class AliRecoServer+;
 #pragma link C++ class  AliQAHistNavigator+;
 #pragma link C++ class  AliQAHistViewer+;
 #pragma link C++ class  AliQADirList+;
diff --git a/MONITOR/MONITORzmqLinkDef.h b/MONITOR/MONITORzmqLinkDef.h
new file mode 100644 (file)
index 0000000..9ff59c1
--- /dev/null
@@ -0,0 +1,16 @@
+#ifdef __CINT__
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#pragma link C++ class AliEventServerWindow+;
+#pragma link C++ class AliRecoServerThread+;
+#pragma link C++ class AliRecoServer+;
+
+#endif
index 19928c5085587a71ef5bb2542e0a667cdcada48f..fdcd361278f31f4dafd7b81677fb8e878f07f242 100644 (file)
@@ -55,7 +55,6 @@ set ( SRCS
     FLOW/Tasks/AliFlowVZEROResults.cxx
     FLOW/Tasks/AliFlowVZEROQA.cxx
     FLOW/Tasks/AliAnalysisTaskFlowEPCascade.cxx
-    FLOW/Tasks/AliAnalysisTaskJetFlow.cxx
     FLOW/Tasks/AliAnalysisTaskJetFlowMC.cxx
     FLOW/Tasks/AliAnalysisTaskMultiparticleCorrelations.cxx
     )
@@ -67,7 +66,7 @@ set ( DHDR PWGflowTasksLinkDef.h)
 set ( EXPORT ${HDRS} )
 
 if( ALICE_TARGET STREQUAL "win32gcc")
-        set ( ELIBS -L${ALICE_ROOT}/lib/tgt_${ALICE_TARGET} -lPWGflowBase -lPWGEMCAL -lPWGJEEMCALJetTasks -lPWGmuon -lANALYSISalice -lANALYSIS -lAOD -lESD -lSTEERBase ${ROOTCLIBS} -lEG )
+        set ( ELIBS -L${ALICE_ROOT}/lib/tgt_${ALICE_TARGET} -lPWGflowBase -lPWGmuon -lANALYSISalice -lANALYSIS -lAOD -lESD -lSTEERBase ${ROOTCLIBS} -lEG )
 endif( ALICE_TARGET STREQUAL "win32gcc")
 
-set ( EINCLUDE PWG/FLOW/Base PWG/FLOW/Tasks STEER/ESD STEER/AOD STEER/STEERBase PWG/EMCAL PWGJE/EMCALJetTasks PWGJE/EMCALJetTasks/UserTasks PWG/muon ANALYSIS)
+set ( EINCLUDE PWG/FLOW/Base PWG/FLOW/Tasks STEER/ESD STEER/AOD STEER/STEERBase PWG/muon ANALYSIS)
index d1ae36ec367e4f692d31a66cc990988d2ae4405b..d5548bd2d33dd3f6116bc73d070ba697a3fe3200 100755 (executable)
@@ -112,7 +112,7 @@ fWriteOutputDeltaAOD(kFALSE),fOldAOD(kFALSE),
 fEMCALClustersListName(""),  fZvtxCut(0.),
 fAcceptFastCluster(kFALSE),  fRemoveLEDEvents(kTRUE),
 //Trigger rejection
-fRemoveBadTriggerEvents(0),  fTriggerPatchClusterMatch(0),
+fRemoveBadTriggerEvents(0),  fTriggerPatchClusterMatch(1),
 fTriggerPatchTimeWindow(),   fTriggerL0EventThreshold(0),
 fTriggerL1EventThreshold(0), fTriggerL1EventThresholdFix(0),
 fTriggerClusterBC(0),        fTriggerClusterIndex(0),         fTriggerClusterId(0),
@@ -378,7 +378,7 @@ Bool_t AliCaloTrackReader::CheckEventTriggers()
   // In case of Mixing, avoid checking the triggers in the min bias events
   if(!fEventTriggerAtSE && (isMB && !isTrigger)) return kTRUE;
   
-  if( IsEventEMCALL1() || IsEventEMCALL0()  )
+  if( (IsEventEMCALL1() || IsEventEMCALL0())  &&  fTriggerPatchClusterMatch)
   {
     if(fRejectEMCalTriggerEventsWith2Tresholds)
     {
index 0c34cbb5900be024062b93a2c4c1c3b3079e5e84..f9976abbd4fea563caec74de230cc427a41ffe0f 100755 (executable)
@@ -71,7 +71,8 @@ ClassImp(AliCalorimeterUtils)
     fPlotCluster(0),                  fOADBSet(kFALSE),
     fOADBForEMCAL(kFALSE),            fOADBForPHOS(kFALSE),
     fOADBFilePathEMCAL(""),           fOADBFilePathPHOS(""),
-    fImportGeometryFromFile(0),       fImportGeometryFilePath("")
+    fImportGeometryFromFile(0),       fImportGeometryFilePath(""),
+    fNSuperModulesUsed(0)
 {
   //Ctor
   
@@ -1218,6 +1219,8 @@ void AliCalorimeterUtils::InitParameters()
   
   fImportGeometryFromFile = kTRUE;
   fImportGeometryFilePath = "";
+  fNSuperModulesUsed = 22;
   
 }
 
index bf7408fb5cf74c68803ac78055970cc57f33ef63..41cbad2bc43eb3e10d99c4141b26ad4d674c7ae4 100755 (executable)
@@ -285,6 +285,8 @@ class AliCalorimeterUtils : public TObject {
   void          SetEMCALOADBFilePath(TString path)              { fOADBFilePathEMCAL  = path    ; }
   void          SetPHOSOADBFilePath (TString path)              { fOADBFilePathPHOS   = path    ; }
 
+  void          SetNumberOfSuperModulesUsed(Int_t nSM)          { fNSuperModulesUsed  = nSM     ; }
+  Int_t         GetNumberOfSuperModulesUsed()             const { return fNSuperModulesUsed     ; }
   
  private:
 
@@ -326,10 +328,14 @@ class AliCalorimeterUtils : public TObject {
   Bool_t             fImportGeometryFromFile;// Import geometry settings in geometry.root file
   TString            fImportGeometryFilePath;// path fo geometry.root file
 
+  Int_t              fNSuperModulesUsed;     // Number of supermodules to be used in analysis, can be different than the real geo,
+                                             // to be used at initialization of histograms
+
+  
   AliCalorimeterUtils(              const AliCalorimeterUtils & cu) ; // cpy ctor
   AliCalorimeterUtils & operator = (const AliCalorimeterUtils & cu) ; // cpy assignment
   
-  ClassDef(AliCalorimeterUtils,15)
+  ClassDef(AliCalorimeterUtils,16)
 } ;
 
 
index ec8c73dd0d27c22777ebe4fdf7d12b02915d70df..b6559d931f5426880110d8f04ad11b70ddeeed69 100644 (file)
@@ -42,6 +42,9 @@
 #include "AliNanoAODReplicator.h"
 #include "AliNanoAODTrackMapping.h"
 
+using std::cout;
+using std::endl;
+
 ClassImp(AliAnalysisTaskNanoAODFilter)
 
 
index cfe95ba4c45084851c222bfe98cef04384c3bd91..10f1a97115fed3ac18c9bec633db45c9dc18edc1 100644 (file)
@@ -93,6 +93,7 @@ AliAnalysisTaskEmcal::AliAnalysisTaskEmcal() :
   fPtHard(0),
   fPtHardBin(0),
   fNTrials(0),
+  fXsection(0),
   fParticleCollArray(),
   fClusterCollArray(),
   fMainTriggerPatch(0x0),
@@ -171,6 +172,7 @@ AliAnalysisTaskEmcal::AliAnalysisTaskEmcal(const char *name, Bool_t histo) :
   fPtHard(0),
   fPtHardBin(0),
   fNTrials(0),
+  fXsection(0),
   fParticleCollArray(),
   fClusterCollArray(),
   fMainTriggerPatch(0x0),
@@ -351,6 +353,13 @@ Bool_t AliAnalysisTaskEmcal::FillGeneralHistograms()
     fHistEventsAfterSel->SetBinContent(fPtHardBin + 1, fHistEventsAfterSel->GetBinContent(fPtHardBin + 1) + 1);
     fHistTrialsAfterSel->SetBinContent(fPtHardBin + 1, fHistTrialsAfterSel->GetBinContent(fPtHardBin + 1) + fNTrials);
     fHistPtHard->Fill(fPtHard);
+    if(fPythiaHeader) {
+      fXsection = fPythiaHeader->GetXsection();
+      if(fXsection>0.) {
+       fHistXsection->Fill(fPtHardBin+1, fXsection);
+       fHistTrials->Fill(fPtHardBin+1, fPythiaHeader->Trials());
+      }
+    }
   }
 
   fHistCentrality->Fill(fCent);
@@ -525,7 +534,6 @@ Bool_t AliAnalysisTaskEmcal::UserNotify()
     return kFALSE;
   }
 
-  Float_t xsection = 0;
   Float_t trials   = 0;
   Int_t   pthard   = 0;
 
@@ -541,13 +549,13 @@ Bool_t AliAnalysisTaskEmcal::UserNotify()
 
   Int_t nevents = tree->GetEntriesFast();
 
-  PythiaInfoFromFile(curfile->GetName(), xsection, trials, pthard);
+  PythiaInfoFromFile(curfile->GetName(), fXsection, trials, pthard);
 
   // TODO: Workaround
   if ((pthard < 0) || (pthard > 10))
     pthard = 0;
   fHistTrials->Fill(pthard, trials);
-  fHistXsection->Fill(pthard, xsection);
+  fHistXsection->Fill(pthard, fXsection);
   fHistEvents->Fill(pthard, nevents);
 
   return kTRUE;
@@ -981,7 +989,7 @@ Bool_t AliAnalysisTaskEmcal::RetrieveEventObjects()
 
     if (fPythiaHeader) {
       fPtHard = fPythiaHeader->GetPtHard();
-    
+
       const Int_t ptHardLo[11] = { 0, 5,11,21,36,57, 84,117,152,191,234};
       const Int_t ptHardHi[11] = { 5,11,21,36,57,84,117,152,191,234,1000000};
       for (fPtHardBin = 0; fPtHardBin < 11; fPtHardBin++) {
index 720a69fb560934e7eb31f8f6b54c503873e67dff..ff42d6f2982abea0b47b4915580f70cc446e239f 100644 (file)
@@ -160,6 +160,7 @@ class AliAnalysisTaskEmcal : public AliAnalysisTaskSE {
   Double_t                    fPtHard;                     //!event pt hard
   Int_t                       fPtHardBin;                  //!event pt hard bin
   Int_t                       fNTrials;                    //!event trials
+  Float_t                     fXsection;                   //!x-section from pythia header
   TObjArray                   fParticleCollArray;          // particle/track collection array
   TObjArray                   fClusterCollArray;           // cluster collection array
   AliEmcalTriggerPatchInfo   *fMainTriggerPatch;           // main trigger patch, will be cached after calling GetMainTriggerPatch() first time
@@ -180,6 +181,6 @@ class AliAnalysisTaskEmcal : public AliAnalysisTaskSE {
   AliAnalysisTaskEmcal(const AliAnalysisTaskEmcal&);            // not implemented
   AliAnalysisTaskEmcal &operator=(const AliAnalysisTaskEmcal&); // not implemented
 
-  ClassDef(AliAnalysisTaskEmcal, 7) // EMCAL base analysis task
+  ClassDef(AliAnalysisTaskEmcal, 8) // EMCAL base analysis task
 };
 #endif
index 0aa933e7b8bcefee7af68e4cd944c815327d1a79..91080159ddb20a5b4ac43935fbb704d5e94ae595 100644 (file)
@@ -53,7 +53,7 @@ AliAnalysisTaskSE *AddTaskEmcalPreparation(const char *perstr  = "LHC11h",
 
   //----------------------- Add clusterizer -------------------------------------------------------
   clusterizer    = AliEMCALRecParam::kClusterizerv2;
-  remExoticCell  = kFALSE;
+  remExoticCell  = kTRUE;
   gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskClusterizerFast.C");
   AliAnalysisTaskEMCALClusterizeFast *clusterizerTask = AddTaskClusterizerFast("ClusterizerFast","","",clusterizer,cellthresh,seedthresh,
                                                                               timeMin,timeMax,timeCut,remExoticCell,distBC,
index 56e3fac8a61a4a5506b249e69a7e57cf5d7c598d..21961c1984642567f47888560e8df8264fa41bfc 100644 (file)
@@ -28,6 +28,8 @@
 using std::endl;
 using std::cout;
 using std::flush;
+using std::ofstream;
+using std::ios;
 
 //================================================================================================================
 
@@ -281,6 +283,8 @@ void AliFlowAnalysisWithMultiparticleCorrelations::CrossCheckPointersUsedInFinis
    else if(fCalculateOnlySin && 0==cs){continue;}
    for(Int_t c=0;c<fMaxCorrelator;c++) 
    {
+    if(c==fDontGoBeyond){continue;}
+    if(fCalculateOnlyForHarmonicQC && c%2==0){continue;}
     if(!fCorrelationsPro[cs][c]){Fatal(sMethodName.Data(),"fCorrelationsPro[%d][%d] is NULL, for one reason or another...",cs,c);}
    }
   }
@@ -332,6 +336,8 @@ void AliFlowAnalysisWithMultiparticleCorrelations::CrossCheckPointersUsedInMake(
    else if(fCalculateOnlySin && 0==cs){continue;}
    for(Int_t c=0;c<fMaxCorrelator;c++) 
    {
+    if(c==fDontGoBeyond){continue;}
+    if(fCalculateOnlyForHarmonicQC && c%2==0){continue;}
     if(!fCorrelationsPro[cs][c]){Fatal(sMethodName.Data(),"fCorrelationsPro[%d][%d] is NULL, for one reason or another...",cs,c);}
    }
   }
@@ -1852,6 +1858,18 @@ void AliFlowAnalysisWithMultiparticleCorrelations::CrossCheckSettings()
  }
 
  // f) Differential correlations:
+ if(fCalculateDiffCorrelations && !fCalculateDiffQvectors)
+ {
+  Fatal(sMethodName.Data(),"fCalculateDiffCorrelations && !fCalculateDiffQvectors"); 
+ }
+ if(fCalculateDiffCorrelations && !fCalculateQvector)
+ {
+  Fatal(sMethodName.Data(),"fCalculateDiffCorrelations && !fCalculateQvector"); 
+ }
+ if(!fCalculateDiffCorrelations && fCalculateDiffQvectors)
+ {
+  Fatal(sMethodName.Data(),"!fCalculateDiffCorrelations && fCalculateDiffQvectors"); 
+ }
  if(fCalculateDiffCorrelations && !fUseDefaultBinning && (fnDiffBins < 1 || !fRangesDiffBins))
  {
   Fatal(sMethodName.Data(),"fCalculateDiffCorrelations && !fUseDefaultBinning && (fnDiffBins < 1 || !fRangesDiffBins)"); 
@@ -1860,6 +1878,10 @@ void AliFlowAnalysisWithMultiparticleCorrelations::CrossCheckSettings()
  {
   Fatal(sMethodName.Data(),"fCalculateDiffCorrelations && !(fCalculateDiffCos || fCalculateDiffSin)"); 
  }
+ if(fCalculateDiffCorrelations && fDontFill[1])
+ {
+  Warning(sMethodName.Data(),"fCalculateDiffCorrelations && fDontFill[1]"); 
+ }
 
  // g) Nested loops:
  if(fCrossCheckDiffWithNestedLoops && (1 == fCrossCheckDiffCSCOBN[0] && !fCalculateDiffSin))
@@ -1992,7 +2014,7 @@ void AliFlowAnalysisWithMultiparticleCorrelations::BookEverythingForControlHisto
  //  b2) Book TH2D *fMultCorrelationsHist[3].
 
  // a) Book the profile holding all the flags for control histograms: TBI stil incomplete 
- fControlHistogramsFlagsPro = new TProfile("fControlHistogramsFlagsPro","Flags and settings for control histograms",4,0,4);
+ fControlHistogramsFlagsPro = new TProfile("fControlHistogramsFlagsPro","Flags and settings for control histograms",7,0,7);
  fControlHistogramsFlagsPro->SetTickLength(-0.01,"Y");
  fControlHistogramsFlagsPro->SetMarkerStyle(25);
  fControlHistogramsFlagsPro->SetLabelSize(0.04);
@@ -2004,6 +2026,9 @@ void AliFlowAnalysisWithMultiparticleCorrelations::BookEverythingForControlHisto
  fControlHistogramsFlagsPro->GetXaxis()->SetBinLabel(2,"fFillKinematicsHist"); fControlHistogramsFlagsPro->Fill(1.5,fFillKinematicsHist);
  fControlHistogramsFlagsPro->GetXaxis()->SetBinLabel(3,"fFillMultDistributionsHist"); fControlHistogramsFlagsPro->Fill(2.5,fFillMultDistributionsHist);
  fControlHistogramsFlagsPro->GetXaxis()->SetBinLabel(4,"fFillMultCorrelationsHist"); fControlHistogramsFlagsPro->Fill(3.5,fFillMultCorrelationsHist);
+ fControlHistogramsFlagsPro->GetXaxis()->SetBinLabel(5,"fDontFill[0=RP]"); fControlHistogramsFlagsPro->Fill(4.5,fDontFill[0]);
+ fControlHistogramsFlagsPro->GetXaxis()->SetBinLabel(6,"fDontFill[1=POI]"); fControlHistogramsFlagsPro->Fill(5.5,fDontFill[1]);
+ fControlHistogramsFlagsPro->GetXaxis()->SetBinLabel(7,"fDontFill[2=REF]"); fControlHistogramsFlagsPro->Fill(6.5,fDontFill[2]);
  fControlHistogramsList->Add(fControlHistogramsFlagsPro);
 
  if(!fFillControlHistograms){return;} // TBI is this safe? Well, perhaps it is if I can't implement it better...
@@ -2019,6 +2044,7 @@ void AliFlowAnalysisWithMultiparticleCorrelations::BookEverythingForControlHisto
  {
   for(Int_t rp=0;rp<2;rp++) // [RP,POI]
   {
+   if(fDontFill[rp]){continue;}
    for(Int_t ppe=0;ppe<3;ppe++) // [phi,pt,eta]
    {
     fKinematicsHist[rp][ppe] = new TH1D(name[rp][ppe].Data(),title[rp].Data(),fnBins[rp][ppe],fMin[rp][ppe],fMax[rp][ppe]);
@@ -2041,6 +2067,7 @@ void AliFlowAnalysisWithMultiparticleCorrelations::BookEverythingForControlHisto
  {
   for(Int_t rprm=0;rprm<3;rprm++) // [RP,POI,reference multiplicity]
   {
+   if(fDontFill[rprm]){continue;}
    fMultDistributionsHist[rprm] = new TH1D(nameMult[rprm].Data(),titleMult[rprm].Data(),fnBinsMult[rprm],fMinMult[rprm],fMaxMult[rprm]);
    fMultDistributionsHist[rprm]->GetXaxis()->SetTitle(xAxisTitleMult[rprm].Data());
    fMultDistributionsHist[rprm]->SetLineColor(lineColorMult[rprm]);
@@ -2052,21 +2079,27 @@ void AliFlowAnalysisWithMultiparticleCorrelations::BookEverythingForControlHisto
  //  b2) Book TH2I *fMultCorrelationsHist[3]: 
  if(fFillMultCorrelationsHist)
  {
-  // ...
-  fMultCorrelationsHist[0] = new TH2I("Multiplicity (RP vs. POI)","Multiplicity (RP vs. POI)",fnBinsMult[0],fMinMult[0],fMaxMult[0],fnBinsMult[1],fMinMult[1],fMaxMult[1]);
-  fMultCorrelationsHist[0]->GetXaxis()->SetTitle(xAxisTitleMult[0].Data());
-  fMultCorrelationsHist[0]->GetYaxis()->SetTitle(xAxisTitleMult[1].Data());
-  fControlHistogramsList->Add(fMultCorrelationsHist[0]);
-  // ...
-  fMultCorrelationsHist[1] = new TH2I("Multiplicity (RP vs. REF)","Multiplicity (RP vs. REF)",fnBinsMult[0],fMinMult[0],fMaxMult[0],fnBinsMult[2],fMinMult[2],fMaxMult[2]);
-  fMultCorrelationsHist[1]->GetXaxis()->SetTitle(xAxisTitleMult[0].Data());
-  fMultCorrelationsHist[1]->GetYaxis()->SetTitle(xAxisTitleMult[2].Data());
-  fControlHistogramsList->Add(fMultCorrelationsHist[1]);
-  // ...
-  fMultCorrelationsHist[2] = new TH2I("Multiplicity (POI vs. REF)","Multiplicity (POI vs. REF)",fnBinsMult[1],fMinMult[1],fMaxMult[1],fnBinsMult[2],fMinMult[2],fMaxMult[2]);
-  fMultCorrelationsHist[2]->GetXaxis()->SetTitle(xAxisTitleMult[1].Data());
-  fMultCorrelationsHist[2]->GetYaxis()->SetTitle(xAxisTitleMult[2].Data());
-  fControlHistogramsList->Add(fMultCorrelationsHist[2]);
+  if(!fDontFill[0] && !fDontFill[1])
+  {
+   fMultCorrelationsHist[0] = new TH2I("Multiplicity (RP vs. POI)","Multiplicity (RP vs. POI)",fnBinsMult[0],fMinMult[0],fMaxMult[0],fnBinsMult[1],fMinMult[1],fMaxMult[1]);
+   fMultCorrelationsHist[0]->GetXaxis()->SetTitle(xAxisTitleMult[0].Data());
+   fMultCorrelationsHist[0]->GetYaxis()->SetTitle(xAxisTitleMult[1].Data());
+   fControlHistogramsList->Add(fMultCorrelationsHist[0]);
+  }
+  if(!fDontFill[0] && !fDontFill[2])
+  {
+   fMultCorrelationsHist[1] = new TH2I("Multiplicity (RP vs. REF)","Multiplicity (RP vs. REF)",fnBinsMult[0],fMinMult[0],fMaxMult[0],fnBinsMult[2],fMinMult[2],fMaxMult[2]);
+   fMultCorrelationsHist[1]->GetXaxis()->SetTitle(xAxisTitleMult[0].Data());
+   fMultCorrelationsHist[1]->GetYaxis()->SetTitle(xAxisTitleMult[2].Data());
+   fControlHistogramsList->Add(fMultCorrelationsHist[1]);
+  }
+  if(!fDontFill[1] && !fDontFill[2])
+  {
+   fMultCorrelationsHist[2] = new TH2I("Multiplicity (POI vs. REF)","Multiplicity (POI vs. REF)",fnBinsMult[1],fMinMult[1],fMaxMult[1],fnBinsMult[2],fMinMult[2],fMaxMult[2]);
+   fMultCorrelationsHist[2]->GetXaxis()->SetTitle(xAxisTitleMult[1].Data());
+   fMultCorrelationsHist[2]->GetYaxis()->SetTitle(xAxisTitleMult[2].Data());
+   fControlHistogramsList->Add(fMultCorrelationsHist[2]);
+  }
  } // if(fFillMultCorrelationsHist){
 
 } // void AliFlowAnalysisWithMultiparticleCorrelations::BookEverythingForControlHistograms()
@@ -2102,7 +2135,7 @@ void AliFlowAnalysisWithMultiparticleCorrelations::FillControlHistograms(AliFlow
      {
       if((0==rp && pTrack->InRPSelection()) || (1==rp && pTrack->InPOISelection())) // TBI 
       { 
-       fKinematicsHist[rp][ppe]->Fill(dPhiPtEta[ppe]);
+       if(fKinematicsHist[rp][ppe]){fKinematicsHist[rp][ppe]->Fill(dPhiPtEta[ppe]);}
       }
      } // for(Int_t ppe=0;ppe<3;ppe++) // [phi,pt,eta]
     } // for(Int_t rp=0;rp<2;rp++) // [RP,POI]
@@ -2117,15 +2150,15 @@ void AliFlowAnalysisWithMultiparticleCorrelations::FillControlHistograms(AliFlow
  Double_t dMult[3] = {dMultRP,dMultPOI,dMultREF};
  for(Int_t rprm=0;rprm<3;rprm++) // [RP,POI,reference multiplicity]
  {
-  if(fFillMultDistributionsHist){fMultDistributionsHist[rprm]->Fill(dMult[rprm]);}      
+  if(fFillMultDistributionsHist && fMultDistributionsHist[rprm]){fMultDistributionsHist[rprm]->Fill(dMult[rprm]);}      
  } 
 
  // c) Fill TH2I *fMultCorrelationsHist[3]:  
  if(fFillMultCorrelationsHist)
  {
-  fMultCorrelationsHist[0]->Fill((Int_t)dMultRP,(Int_t)dMultPOI); // RP vs. POI
-  fMultCorrelationsHist[1]->Fill((Int_t)dMultRP,(Int_t)dMultREF); // RP vs. refMult
-  fMultCorrelationsHist[2]->Fill((Int_t)dMultPOI,(Int_t)dMultREF); // POI vs. refMult
+  if(fMultCorrelationsHist[0]){fMultCorrelationsHist[0]->Fill((Int_t)dMultRP,(Int_t)dMultPOI);} // RP vs. POI
+  if(fMultCorrelationsHist[1]){fMultCorrelationsHist[1]->Fill((Int_t)dMultRP,(Int_t)dMultREF);} // RP vs. refMult
+  if(fMultCorrelationsHist[2]){fMultCorrelationsHist[2]->Fill((Int_t)dMultPOI,(Int_t)dMultREF);} // POI vs. refMult
  } // if(fFillMultCorrelationsHist)
 
 } // void AliFlowAnalysisWithMultiparticleCorrelations::FillControlHistograms(AliFlowEventSimple *anEvent)
@@ -2139,8 +2172,9 @@ void AliFlowAnalysisWithMultiparticleCorrelations::InitializeArraysForControlHis
  // a) Initialize TH1D *fKinematicsHist[2][3];
  // b) Initialize TH1D *fMultDistributionsHist[3]; 
  // c) Initialize TH2D *fMultCorrelationsHist[3];  
- // d) Initialize default binning values for fKinematicsHist[2][3];
- // e) Initialize default binning values for fMultCorrelationsHist[3].
+ // d) Initialize Bool_t fDontFill[3];   
+ // e) Initialize default binning values for fKinematicsHist[2][3];
+ // f) Initialize default binning values for fMultCorrelationsHist[3].
  
  // a) Initialize TH1D *fKinematicsHist[2][3]:
  for(Int_t rp=0;rp<2;rp++) // [RP,POI]
@@ -2163,7 +2197,13 @@ void AliFlowAnalysisWithMultiparticleCorrelations::InitializeArraysForControlHis
   fMultCorrelationsHist[r] = NULL; 
  }
 
- // d) Initialize default binning values for fKinematicsHist[2][3]:
+ // d) Initialize Bool_t fDontFill[3]:
+ for(Int_t rpr=0;rpr<3;rpr++) // [RP,POI,REF]
+ {
+  fDontFill[rpr] = kFALSE;
+ }
+
+ // e) Initialize default binning values for fKinematicsHist[2][3]:
  // nBins:
  fnBins[0][0] = 360;  // [RP][phi]
  fnBins[0][1] = 1000; // [RP][pt]
@@ -2186,7 +2226,7 @@ void AliFlowAnalysisWithMultiparticleCorrelations::InitializeArraysForControlHis
  fMax[1][1] = 10.;            // [POI][pt]
  fMax[1][2] = 1.;             // [POI][eta]
 
- // e) Initialize default binning values for fMultCorrelationsHist[3]:
+ // f) Initialize default binning values for fMultCorrelationsHist[3]:
  // nBins:
  fnBinsMult[0] = 3000; // [RP]
  fnBinsMult[1] = 3000; // [POI]
@@ -2291,6 +2331,8 @@ void AliFlowAnalysisWithMultiparticleCorrelations::BookEverythingForCorrelations
   else if(fCalculateOnlySin && 0==cs){continue;}
   for(Int_t c=0;c<fMaxCorrelator;c++) // [1p,2p,...,8p]
   {
+   if(c==fDontGoBeyond){continue;}
+   if(fCalculateOnlyForHarmonicQC && c%2==0){continue;}
    fCorrelationsPro[cs][c] = new TProfile(Form("%dpCorrelations%s",c+1,sCosSin[cs].Data()),"",nBins[c],0.,1.*nBins[c]);
    fCorrelationsPro[cs][c]->Sumw2();
    fCorrelationsPro[cs][c]->SetStats(kFALSE);
@@ -2322,7 +2364,7 @@ void AliFlowAnalysisWithMultiparticleCorrelations::BookEverythingForCorrelations
    {
     if(fCalculateOnlyCos && 1==cs){continue;}
     else if(fCalculateOnlySin && 0==cs){continue;}
-    fCorrelationsPro[cs][0]->GetXaxis()->SetBinLabel(binNo[cs][0]++,Form("%s(%d)",sCosSin[cs].Data(),n1));
+    if(fCorrelationsPro[cs][0]){fCorrelationsPro[cs][0]->GetXaxis()->SetBinLabel(binNo[cs][0]++,Form("%s(%d)",sCosSin[cs].Data(),n1));}
    } // for(Int_t cs=0;cs<2;cs++) 
    nToBeFilled[0]++; 
   }
@@ -2340,7 +2382,7 @@ void AliFlowAnalysisWithMultiparticleCorrelations::BookEverythingForCorrelations
     {
      if(fCalculateOnlyCos && 1==cs){continue;}
      else if(fCalculateOnlySin && 0==cs){continue;}
-     fCorrelationsPro[cs][1]->GetXaxis()->SetBinLabel(binNo[cs][1]++,Form("%s(%d,%d)",sCosSin[cs].Data(),n1,n2));
+     if(fCorrelationsPro[cs][1]){fCorrelationsPro[cs][1]->GetXaxis()->SetBinLabel(binNo[cs][1]++,Form("%s(%d,%d)",sCosSin[cs].Data(),n1,n2));}
     } // for(Int_t cs=0;cs<2;cs++) 
     nToBeFilled[1]++; 
    }
@@ -2357,7 +2399,7 @@ void AliFlowAnalysisWithMultiparticleCorrelations::BookEverythingForCorrelations
      {
       if(fCalculateOnlyCos && 1==cs){continue;}
       else if(fCalculateOnlySin && 0==cs){continue;}
-      fCorrelationsPro[cs][2]->GetXaxis()->SetBinLabel(binNo[cs][2]++,Form("%s(%d,%d,%d)",sCosSin[cs].Data(),n1,n2,n3));
+      if(fCorrelationsPro[cs][2]){fCorrelationsPro[cs][2]->GetXaxis()->SetBinLabel(binNo[cs][2]++,Form("%s(%d,%d,%d)",sCosSin[cs].Data(),n1,n2,n3));}
      } // for(Int_t cs=0;cs<2;cs++) 
      nToBeFilled[2]++; 
     }
@@ -2375,7 +2417,7 @@ void AliFlowAnalysisWithMultiparticleCorrelations::BookEverythingForCorrelations
       {
        if(fCalculateOnlyCos && 1==cs){continue;}
        else if(fCalculateOnlySin && 0==cs){continue;}
-       fCorrelationsPro[cs][3]->GetXaxis()->SetBinLabel(binNo[cs][3]++,Form("%s(%d,%d,%d,%d)",sCosSin[cs].Data(),n1,n2,n3,n4));
+       if(fCorrelationsPro[cs][3]){fCorrelationsPro[cs][3]->GetXaxis()->SetBinLabel(binNo[cs][3]++,Form("%s(%d,%d,%d,%d)",sCosSin[cs].Data(),n1,n2,n3,n4));}
       } // for(Int_t cs=0;cs<2;cs++) 
       nToBeFilled[3]++; 
      } 
@@ -2393,7 +2435,7 @@ void AliFlowAnalysisWithMultiparticleCorrelations::BookEverythingForCorrelations
        {
         if(fCalculateOnlyCos && 1==cs){continue;}
         else if(fCalculateOnlySin && 0==cs){continue;}
-        fCorrelationsPro[cs][4]->GetXaxis()->SetBinLabel(binNo[cs][4]++,Form("%s(%d,%d,%d,%d,%d)",sCosSin[cs].Data(),n1,n2,n3,n4,n5));
+        if(fCorrelationsPro[cs][4]){fCorrelationsPro[cs][4]->GetXaxis()->SetBinLabel(binNo[cs][4]++,Form("%s(%d,%d,%d,%d,%d)",sCosSin[cs].Data(),n1,n2,n3,n4,n5));}
        } // for(Int_t cs=0;cs<2;cs++) 
        nToBeFilled[4]++; 
       }
@@ -2413,7 +2455,7 @@ void AliFlowAnalysisWithMultiparticleCorrelations::BookEverythingForCorrelations
         {
          if(fCalculateOnlyCos && 1==cs){continue;}
          else if(fCalculateOnlySin && 0==cs){continue;}
-         fCorrelationsPro[cs][5]->GetXaxis()->SetBinLabel(binNo[cs][5]++,Form("%s(%d,%d,%d,%d,%d,%d)",sCosSin[cs].Data(),n1,n2,n3,n4,n5,n6));         
+         if(fCorrelationsPro[cs][5]){fCorrelationsPro[cs][5]->GetXaxis()->SetBinLabel(binNo[cs][5]++,Form("%s(%d,%d,%d,%d,%d,%d)",sCosSin[cs].Data(),n1,n2,n3,n4,n5,n6));}         
         } // for(Int_t cs=0;cs<2;cs++) 
         nToBeFilled[5]++; 
        }
@@ -2433,7 +2475,7 @@ void AliFlowAnalysisWithMultiparticleCorrelations::BookEverythingForCorrelations
          {
           if(fCalculateOnlyCos && 1==cs){continue;}
           else if(fCalculateOnlySin && 0==cs){continue;}
-          fCorrelationsPro[cs][6]->GetXaxis()->SetBinLabel(binNo[cs][6]++,Form("%s(%d,%d,%d,%d,%d,%d,%d)",sCosSin[cs].Data(),n1,n2,n3,n4,n5,n6,n7));
+          if(fCorrelationsPro[cs][6]){fCorrelationsPro[cs][6]->GetXaxis()->SetBinLabel(binNo[cs][6]++,Form("%s(%d,%d,%d,%d,%d,%d,%d)",sCosSin[cs].Data(),n1,n2,n3,n4,n5,n6,n7));}
          } // for(Int_t cs=0;cs<2;cs++) 
          nToBeFilled[6]++; 
         }
@@ -2454,7 +2496,7 @@ void AliFlowAnalysisWithMultiparticleCorrelations::BookEverythingForCorrelations
           {
            if(fCalculateOnlyCos && 1==cs){continue;}
            else if(fCalculateOnlySin && 0==cs){continue;}
-           fCorrelationsPro[cs][7]->GetXaxis()->SetBinLabel(binNo[cs][7]++,Form("%s(%d,%d,%d,%d,%d,%d,%d,%d)",sCosSin[cs].Data(),n1,n2,n3,n4,n5,n6,n7,n8));
+           if(fCorrelationsPro[cs][7]){fCorrelationsPro[cs][7]->GetXaxis()->SetBinLabel(binNo[cs][7]++,Form("%s(%d,%d,%d,%d,%d,%d,%d,%d)",sCosSin[cs].Data(),n1,n2,n3,n4,n5,n6,n7,n8));}
           } // for(Int_t cs=0;cs<2;cs++) 
           nToBeFilled[7]++; 
          }
@@ -2473,6 +2515,7 @@ void AliFlowAnalysisWithMultiparticleCorrelations::BookEverythingForCorrelations
   else if(fCalculateOnlySin && 0==cs){continue;}
   for(Int_t c=0;c<fMaxCorrelator;c++) // [1p,2p,...,8p]
   {
+   if(!fCorrelationsPro[cs][c]){continue;}
    fCorrelationsPro[cs][c]->SetTitle(Form("%d-p correlations, %s terms, %d/%d in total",c+1,sCosSin[cs].Data(),nToBeFilled[c],nBinsTitle[c]));
    fCorrelationsPro[cs][c]->GetXaxis()->SetRangeUser(0.,fCorrelationsPro[cs][c]->GetBinLowEdge(nToBeFilled[c]+1));
   }
@@ -2508,6 +2551,8 @@ void AliFlowAnalysisWithMultiparticleCorrelations::BookEverythingForDiffCorrelat
  fDiffCorrelationsFlagsPro->GetXaxis()->SetBinLabel(5,"fUseDefaultBinning"); fDiffCorrelationsFlagsPro->Fill(4.5,fUseDefaultBinning); 
  fDiffCorrelationsList->Add(fDiffCorrelationsFlagsPro);
 
+ if(!fCalculateDiffCorrelations){return;}  
+
  // b) Book TProfile *fDiffCorrelationsPro[2][4] ([0=cos,1=sin][1p,2p,3p,4p]):
  Bool_t fDiffStore[2][4] = {{0,1,1,1},{0,0,0,0}}; // store or not TBI promote to data member, and implement setter perhaps  
  Int_t markerColor[2] = {kRed,kGreen};
@@ -3064,6 +3109,9 @@ void AliFlowAnalysisWithMultiparticleCorrelations::GetPointersForControlHistogra
  fFillKinematicsHist = fControlHistogramsFlagsPro->GetBinContent(2);
  fFillMultDistributionsHist = fControlHistogramsFlagsPro->GetBinContent(3);
  fFillMultCorrelationsHist = fControlHistogramsFlagsPro->GetBinContent(4);
+ fDontFill[0] = fControlHistogramsFlagsPro->GetBinContent(5);
+ fDontFill[1] = fControlHistogramsFlagsPro->GetBinContent(6);
+ fDontFill[2] = fControlHistogramsFlagsPro->GetBinContent(7);
 
  if(!fFillControlHistograms){return;} // TBI is this safe enough
 
@@ -3071,6 +3119,7 @@ void AliFlowAnalysisWithMultiparticleCorrelations::GetPointersForControlHistogra
  TString name[2][3] = {{"RP,phi","RP,pt","RP,eta"},{"POI,phi","POI,pt","POI,eta"}}; // [RP,POI][phi,pt,eta]
  for(Int_t rp=0;rp<2;rp++) // [RP,POI]
  {
+  if(fDontFill[rp]){continue;}
   for(Int_t ppe=0;ppe<3;ppe++) // [phi,pt,eta]
   {
    fKinematicsHist[rp][ppe] = dynamic_cast<TH1D*>(fControlHistogramsList->FindObject(name[rp][ppe].Data()));
@@ -3082,17 +3131,27 @@ void AliFlowAnalysisWithMultiparticleCorrelations::GetPointersForControlHistogra
  TString nameMult[3] = {"Multiplicity (RP)","Multiplicity (POI)","Multiplicity (REF)"}; // [RP,POI,reference multiplicity]
  for(Int_t rprm=0;rprm<3;rprm++) // [RP,POI,reference multiplicity]
  {
+  if(fDontFill[rprm]){continue;}
   fMultDistributionsHist[rprm] = dynamic_cast<TH1D*>(fControlHistogramsList->FindObject(nameMult[rprm].Data()));
   if(!fMultDistributionsHist[rprm] && fFillMultDistributionsHist){Fatal(sMethodName.Data(),"%s",nameMult[rprm].Data());} // TBI 
  } // for(Int_t rprm=0;rprm<3;rprm++) // [RP,POI,reference multiplicity]
 
- // f) Get pointers to TH2I *fMultCorrelationsHist[3]: TBI automatize the things here...
- fMultCorrelationsHist[0] = dynamic_cast<TH2I*>(fControlHistogramsList->FindObject("Multiplicity (RP vs. POI)"));
- if(!fMultCorrelationsHist[0] && fFillMultCorrelationsHist){Fatal(sMethodName.Data(),"Multiplicity (RP vs. POI)");} // TBI 
- fMultCorrelationsHist[1] = dynamic_cast<TH2I*>(fControlHistogramsList->FindObject("Multiplicity (RP vs. REF)"));
- if(!fMultCorrelationsHist[1] && fFillMultCorrelationsHist){Fatal(sMethodName.Data(),"Multiplicity (RP vs. REF)");} // TBI 
- fMultCorrelationsHist[2] = dynamic_cast<TH2I*>(fControlHistogramsList->FindObject("Multiplicity (POI vs. REF)"));
- if(!fMultCorrelationsHist[2] && fFillMultCorrelationsHist){Fatal(sMethodName.Data(),"Multiplicity (POI vs. REF)");} // TBI 
+ // f) Get pointers to TH2I *fMultCorrelationsHist[3]: TBI automatize the things here (at some point...)...
+ if(!fDontFill[0] && !fDontFill[1])
+ {
+  fMultCorrelationsHist[0] = dynamic_cast<TH2I*>(fControlHistogramsList->FindObject("Multiplicity (RP vs. POI)"));
+  if(!fMultCorrelationsHist[0] && fFillMultCorrelationsHist){Fatal(sMethodName.Data(),"Multiplicity (RP vs. POI)");} // TBI 
+ }
+ if(!fDontFill[0] && !fDontFill[2])
+ {
+  fMultCorrelationsHist[1] = dynamic_cast<TH2I*>(fControlHistogramsList->FindObject("Multiplicity (RP vs. REF)"));
+  if(!fMultCorrelationsHist[1] && fFillMultCorrelationsHist){Fatal(sMethodName.Data(),"Multiplicity (RP vs. REF)");} // TBI 
+ }
+ if(!fDontFill[1] && !fDontFill[2])
+ {
+  fMultCorrelationsHist[2] = dynamic_cast<TH2I*>(fControlHistogramsList->FindObject("Multiplicity (POI vs. REF)"));
+  if(!fMultCorrelationsHist[2] && fFillMultCorrelationsHist){Fatal(sMethodName.Data(),"Multiplicity (POI vs. REF)");} // TBI 
+ }
 
 } // void AliFlowAnalysisWithMultiparticleCorrelations::GetPointersForControlHistograms()
 
@@ -3143,6 +3202,8 @@ void AliFlowAnalysisWithMultiparticleCorrelations::GetPointersForCorrelations()
   else if(fCalculateOnlySin && 0==cs){continue;}
   for(Int_t c=0;c<fMaxCorrelator;c++)
   {
+   if(c==fDontGoBeyond){continue;}
+   if(fCalculateOnlyForHarmonicQC && c%2==0){continue;}
    fCorrelationsPro[cs][c] = dynamic_cast<TProfile*>(fCorrelationsList->FindObject(Form("%dpCorrelations%s",c+1,sCosSin[cs].Data())));
    if(!fCorrelationsPro[cs][c]){Fatal(sMethodName.Data(),"%dpCorrelations%s",c+1,sCosSin[cs].Data());} 
   }
@@ -3222,6 +3283,7 @@ void AliFlowAnalysisWithMultiparticleCorrelations::GetPointersForDiffCorrelation
 
  if(!fCalculateDiffCorrelations){return;} 
 
+ // TBI get all pointers below for diff. stuff eventually, not needed for the time being. 
 
  // d) Get pointers to TProfile *fDiffCorrelationsPro[2][4]: // TBI
  /*
@@ -4397,7 +4459,7 @@ Double_t AliFlowAnalysisWithMultiparticleCorrelations::Covariance(const char *x,
 
  return wCov;
 
-} // Double_t AliFlowAnalysisWithMultiparticleCorrelationsCovariance(const char *x, const char *y, TProfile2D *profile2D, Bool_t bUnbiasedEstimator = kFALSE)
+} // Double_t AliFlowAnalysisWithMultiparticleCorrelations::Covariance(const char *x, const char *y, TProfile2D *profile2D, Bool_t bUnbiasedEstimator = kFALSE)
 
 //=======================================================================================================================
 
@@ -4596,11 +4658,11 @@ void AliFlowAnalysisWithMultiparticleCorrelations::InitializeArraysForWeights()
 
 //=======================================================================================================================
 
-void AliFlowAnalysisWithMultiparticleCorrelations::SetnBins(const char *type, const char *variable, const Int_t nBins)
+void AliFlowAnalysisWithMultiparticleCorrelations::SetnBins(const char *type, const char *variable, Int_t nBins)
 {
  // Set number of bins for histograms fKinematicsHist[2][3].
 
- TString sMethodName = "void AliFlowAnalysisWithMultiparticleCorrelations::SetnBins(const char *type, const char *variable, const Int_t nBins)";
+ TString sMethodName = "void AliFlowAnalysisWithMultiparticleCorrelations::SetnBins(const char *type, const char *variable, Int_t nBins)";
  
  // Basic protection:
  if(!(TString(type).EqualTo("RP") || TString(type).EqualTo("POI")))
@@ -4623,15 +4685,15 @@ void AliFlowAnalysisWithMultiparticleCorrelations::SetnBins(const char *type, co
 
  fnBins[rp][ppe] = nBins;
 
-} // void AliFlowAnalysisWithMultiparticleCorrelations::SetnBins(const char *type, const char *variable, const Int_t nBins)
+} // void AliFlowAnalysisWithMultiparticleCorrelations::SetnBins(const char *type, const char *variable, Int_t nBins)
 
 //=======================================================================================================================
 
-void AliFlowAnalysisWithMultiparticleCorrelations::SetMin(const char *type, const char *variable, const Double_t min)
+void AliFlowAnalysisWithMultiparticleCorrelations::SetMin(const char *type, const char *variable, Double_t min)
 {
  // Set min bin range for histograms fKinematicsHist[2][3].
 
- TString sMethodName = "void AliFlowAnalysisWithMultiparticleCorrelations::SetMin(const char *type, const char *variable, const Double_t min)";
+ TString sMethodName = "void AliFlowAnalysisWithMultiparticleCorrelations::SetMin(const char *type, const char *variable, Double_t min)";
  
  // Basic protection:
  if(!(TString(type).EqualTo("RP") || TString(type).EqualTo("POI")))
@@ -4654,15 +4716,15 @@ void AliFlowAnalysisWithMultiparticleCorrelations::SetMin(const char *type, cons
 
  fMin[rp][ppe] = min;
 
-} // void AliFlowAnalysisWithMultiparticleCorrelations::SetMin(const char *type, const char *variable, const Double_t min)
+} // void AliFlowAnalysisWithMultiparticleCorrelations::SetMin(const char *type, const char *variable, Double_t min)
 
 //=======================================================================================================================
 
-void AliFlowAnalysisWithMultiparticleCorrelations::SetMax(const char *type, const char *variable, const Double_t max)
+void AliFlowAnalysisWithMultiparticleCorrelations::SetMax(const char *type, const char *variable, Double_t max)
 {
  // Set max bin range for histograms fKinematicsHist[2][3].
 
- TString sMethodName = "void AliFlowAnalysisWithMultiparticleCorrelations::SetMax(const char *type, const char *variable, const Double_t max)";
+ TString sMethodName = "void AliFlowAnalysisWithMultiparticleCorrelations::SetMax(const char *type, const char *variable, Double_t max)";
  
  // Basic protection:
  if(!(TString(type).EqualTo("RP") || TString(type).EqualTo("POI")))
@@ -4685,15 +4747,15 @@ void AliFlowAnalysisWithMultiparticleCorrelations::SetMax(const char *type, cons
 
  fMax[rp][ppe] = max;
 
-} // void AliFlowAnalysisWithMultiparticleCorrelations::SetMax(const char *type, const char *variable, const Double_t min)
+} // void AliFlowAnalysisWithMultiparticleCorrelations::SetMax(const char *type, const char *variable, Double_t min)
 
 //=======================================================================================================================
 
-void AliFlowAnalysisWithMultiparticleCorrelations::SetnBinsMult(const char *type, const Int_t nBinsMult)
+void AliFlowAnalysisWithMultiparticleCorrelations::SetnBinsMult(const char *type, Int_t nBinsMult)
 {
  // Set number of bins for histograms fMultDistributionsHist[3].
 
- TString sMethodName = "void AliFlowAnalysisWithMultiparticleCorrelations::SetnBinsMult(const char *type, const Int_t nBinsMult)";
+ TString sMethodName = "void AliFlowAnalysisWithMultiparticleCorrelations::SetnBinsMult(const char *type, Int_t nBinsMult)";
  
  // Basic protection:
  if(!(TString(type).EqualTo("RP") || TString(type).EqualTo("POI") || TString(type).EqualTo("REF")))
@@ -4708,15 +4770,15 @@ void AliFlowAnalysisWithMultiparticleCorrelations::SetnBinsMult(const char *type
 
  fnBinsMult[rpr] = nBinsMult;
 
-} // void AliFlowAnalysisWithMultiparticleCorrelations::SetnBinsMult(const char *type, const Int_t nBinsMult)
+} // void AliFlowAnalysisWithMultiparticleCorrelations::SetnBinsMult(const char *type, Int_t nBinsMult)
 
 //=======================================================================================================================
 
-void AliFlowAnalysisWithMultiparticleCorrelations::SetMinMult(const char *type, const Double_t minMult)
+void AliFlowAnalysisWithMultiparticleCorrelations::SetMinMult(const char *type, Double_t minMult)
 {
  // Set min bin range for histograms fMultDistributionsHist[3].
 
- TString sMethodName = "void AliFlowAnalysisWithMultiparticleCorrelations::SetMinMult(const char *type, const Double_t minMult)";
+ TString sMethodName = "void AliFlowAnalysisWithMultiparticleCorrelations::SetMinMult(const char *type, Double_t minMult)";
  
  // Basic protection:
  if(!(TString(type).EqualTo("RP") || TString(type).EqualTo("POI") || TString(type).EqualTo("REF")))
@@ -4731,15 +4793,15 @@ void AliFlowAnalysisWithMultiparticleCorrelations::SetMinMult(const char *type,
 
  fMinMult[rpr] = minMult;
 
-} // void AliFlowAnalysisWithMultiparticleCorrelations::SetMinMult(const char *type const Double_t minMult)
+} // void AliFlowAnalysisWithMultiparticleCorrelations::SetMinMult(const char *type, Double_t minMult)
 
 //=======================================================================================================================
 
-void AliFlowAnalysisWithMultiparticleCorrelations::SetMaxMult(const char *type, const Double_t maxMult)
+void AliFlowAnalysisWithMultiparticleCorrelations::SetMaxMult(const char *type, Double_t maxMult)
 {
  // Set max bin range for histograms fMultDistributionsHist[3].
 
- TString sMethodName = "void AliFlowAnalysisWithMultiparticleCorrelations::SetMaxMult(const char *type, const Double_t maxMult)";
+ TString sMethodName = "void AliFlowAnalysisWithMultiparticleCorrelations::SetMaxMult(const char *type, Double_t maxMult)";
  
  // Basic protection:
  if(!(TString(type).EqualTo("RP") || TString(type).EqualTo("POI") || TString(type).EqualTo("REF")))
@@ -4754,7 +4816,7 @@ void AliFlowAnalysisWithMultiparticleCorrelations::SetMaxMult(const char *type,
 
  fMaxMult[rpr]&nb