From: akisiel Date: Fri, 23 Oct 2009 09:34:29 +0000 (+0000) Subject: New analysis config macro X-Git-Url: http://git.uio.no/git/?a=commitdiff_plain;h=ce84bcfaf496b0f6bebca04f0216edc98e822c8c;p=u%2Fmrichter%2FAliRoot.git New analysis config macro --- diff --git a/PWG2/FEMTOSCOPY/macros/Train/Train3/ConfigFemtoAnalysis.C b/PWG2/FEMTOSCOPY/macros/Train/Train3/ConfigFemtoAnalysis.C new file mode 100644 index 00000000000..dd1971d92bf --- /dev/null +++ b/PWG2/FEMTOSCOPY/macros/Train/Train3/ConfigFemtoAnalysis.C @@ -0,0 +1,608 @@ +/********************************************************************* + * * + * ConfigFemtoAnalysis.C - configuration macro for the femtoscopic * + * analysis, to be run in the analysis train. * + * Assumed input data: large (>10M) sample of MC pp events * + * Inluded analysis: * + * - positive pion HBT, 3 kt bins, 1D+3D functions * + * - negative pion HBT, 3 kt bins, 1D+3D functions * + * - positive kaon HBT, 1 kt bin, 1D+3D functions * + * * + * Author: Adam Kisiel (Adam.Kisiel@cern.ch) * + * * + *********************************************************************/ + +#if !defined(__CINT__) || defined(__MAKECINT_) +#include "AliFemtoManager.h" +#include "AliFemtoEventReaderESDChain.h" +#include "AliFemtoEventReaderESDChainKine.h" +#include "AliFemtoSimpleAnalysis.h" +#include "AliFemtoBasicEventCut.h" +#include "AliFemtoESDTrackCut.h" +#include "AliFemtoCorrFctn.h" +#include "AliFemtoCutMonitorParticleYPt.h" +#include "AliFemtoCutMonitorParticleVertPos.h" +#include "AliFemtoCutMonitorParticleMomRes.h" +#include "AliFemtoCutMonitorEventMult.h" +#include "AliFemtoCutMonitorEventVertex.h" +#include "AliFemtoShareQualityTPCEntranceSepPairCut.h" +#include "AliFemtoQinvCorrFctn.h" +#include "AliFemtoShareQualityCorrFctn.h" +#include "AliFemtoTPCInnerCorrFctn.h" +#include "AliFemtoVertexMultAnalysis.h" +#include "AliFemtoCorrFctn3DSpherical.h" +#include "AliFemtoChi2CorrFctn.h" +#include "AliFemtoCorrFctnTPCNcls.h" +#include "AliFemtoModelBPLCMSCorrFctn.h" +#include "AliFemtoModelCorrFctn3DSpherical.h" +#include "AliFemtoModelGausLCMSFreezeOutGenerator.h" +#include "AliFemtoModelGausRinvFreezeOutGenerator.h" +#include "AliFemtoModelManager.h" +#include "AliFemtoModelWeightGeneratorBasic.h" +#include "AliFemtoModelWeightGeneratorLednicky.h" +#include "AliFemtoCorrFctnDirectYlm.h" +#include "AliFemtoModelCorrFctnDirectYlm.h" +#include "AliFemtoModelCorrFctnSource.h" +#include "AliFemtoCutMonitorParticlePtPDG.h" +#include "AliFemtoKTPairCut.h" +#endif + +//________________________________________________________________________ +AliFemtoManager* ConfigFemtoAnalysis() { + + double PionMass = 0.13956995; + double KaonMass = 0.493677; + + AliFemtoEventReaderESDChainKine* Reader=new AliFemtoEventReaderESDChainKine(); + Reader->SetConstrained(true); + Reader->SetUseTPCOnly(false); + + AliFemtoManager* Manager=new AliFemtoManager(); + Manager->SetEventReader(Reader); + + int runPositivePions = 1; + int runNegativePions = 1; + int runPositiveKaons = 1; + int runNegativeKaons = 1; + + + if (runPositivePions) { + // *** Begin pion-pion (positive) analysis *** + AliFemtoVertexMultAnalysis *anpip = new AliFemtoVertexMultAnalysis(3, -15.6, 15.6, 1, 2, 200000); + anpip->SetNumEventsToMix(10); + anpip->SetMinSizePartCollection(2); + + AliFemtoBasicEventCut* mecpip = new AliFemtoBasicEventCut(); + mecpip->SetEventMult(2,100000); + mecpip->SetVertZPos(-1000,1000); + + AliFemtoESDTrackCut* dtcpip = new AliFemtoESDTrackCut(); + dtcpip->SetPidProbPion(0.2,1.001); + dtcpip->SetPidProbMuon(0.0,1.0); + dtcpip->SetPidProbKaon(0.0,1.0); + dtcpip->SetPidProbProton(0.0,1.0); + dtcpip->SetCharge(1.0); + dtcpip->SetPt(0.15,0.5); + dtcpip->SetRapidity(-0.8,0.8); + dtcpip->SetMass(PionMass); + // Track quality cuts + dtcpip->SetStatus(AliESDtrack::kTPCrefit|AliESDtrack::kITSrefit); + // dtcpip->SetStatus(AliESDtrack::kTPCrefit); + dtcpip->SetminTPCncls(50); + dtcpip->SetRemoveKinks(kTRUE); + dtcpip->SetLabel(kFALSE); + dtcpip->SetMaxITSChiNdof(2.5); + dtcpip->SetMaxTPCChiNdof(3.0); + dtcpip->SetMaxImpactXY(3.0); + dtcpip->SetMaxImpactZ(3.0); + + // Track monitors + AliFemtoCutMonitorParticleYPt *cutPassYPtpip = new AliFemtoCutMonitorParticleYPt("cutPasspip", 0.13957); + AliFemtoCutMonitorParticleYPt *cutFailYPtpip = new AliFemtoCutMonitorParticleYPt("cutFailpip", 0.13957); + dtcpip->AddCutMonitor(cutPassYPtpip, cutFailYPtpip); + + AliFemtoCutMonitorEventMult *cutPassEvMpip = new AliFemtoCutMonitorEventMult("cutPasspip"); + AliFemtoCutMonitorEventMult *cutFailEvMpip = new AliFemtoCutMonitorEventMult("cutFailpip"); + mecpip->AddCutMonitor(cutPassEvMpip, cutFailEvMpip); + + AliFemtoCutMonitorEventVertex *cutPassEvVpip = new AliFemtoCutMonitorEventVertex("cutPasspip"); + AliFemtoCutMonitorEventVertex *cutFailEvVpip = new AliFemtoCutMonitorEventVertex("cutFailpip"); + mecpip->AddCutMonitor(cutPassEvVpip, cutFailEvVpip); + + // Pair cut + AliFemtoShareQualityTPCEntranceSepPairCut *sqpcpip = new AliFemtoShareQualityTPCEntranceSepPairCut(); + sqpcpip->SetShareQualityMax(0.0); + sqpcpip->SetShareFractionMax(0.02); + sqpcpip->SetRemoveSameLabel(kFALSE); + sqpcpip->SetTPCEntranceSepMinimum(2.0); + + anpip->SetEventCut(mecpip); + anpip->SetFirstParticleCut(dtcpip); + anpip->SetSecondParticleCut(dtcpip); + anpip->SetPairCut(sqpcpip); + + // Two-track quality monitoring + AliFemtoShareQualityCorrFctn *csqqinvpip= new AliFemtoShareQualityCorrFctn("sqqinvcfpip",40,0.0,0.4); + AliFemtoChi2CorrFctn *cchiqinvpip= new AliFemtoChi2CorrFctn("chicfpip",40,0.0,0.4); + AliFemtoCorrFctnTPCNcls *cqtpcnclspip = new AliFemtoCorrFctnTPCNcls("cqtpcnclspip",40,0.0,0.4); + + // Intrdouce kT binning + AliFemtoKTPairCut *ktpairkT1pip = new AliFemtoKTPairCut(0.1,0.27); + AliFemtoKTPairCut *ktpairkT2pip = new AliFemtoKTPairCut(0.27,0.37); + AliFemtoKTPairCut *ktpairkT3pip = new AliFemtoKTPairCut(0.37,0.52); + + // Purely experimental correlation function + AliFemtoCorrFctnDirectYlm *cylmkT1pip = new AliFemtoCorrFctnDirectYlm("cylmkT1pip",3,80,0.0,0.8,1); + cylmkT1pip->SetPairSelectionCut(ktpairkT1pip); + anpip->AddCorrFctn(cylmkT1pip); + + AliFemtoCorrFctnDirectYlm *cylmkT2pip = new AliFemtoCorrFctnDirectYlm("cylmkT2pip",3,80,0.0,0.8,1); + cylmkT2pip->SetPairSelectionCut(ktpairkT2pip); + anpip->AddCorrFctn(cylmkT2pip); + + AliFemtoCorrFctnDirectYlm *cylmkT3pip = new AliFemtoCorrFctnDirectYlm("cylmkT3pip",3,80,0.0,0.8,1); + cylmkT3pip->SetPairSelectionCut(ktpairkT3pip); + anpip->AddCorrFctn(cylmkT3pip); + + AliFemtoQinvCorrFctn *cqinvkt1pip = new AliFemtoQinvCorrFctn("qinvcfkt1pip", 100,0.0,1.0); + cqinvkt1pip->SetPairSelectionCut(ktpairkT1pip); + anpip->AddCorrFctn(cqinvkt1pip); + + AliFemtoQinvCorrFctn *cqinvkt2pip = new AliFemtoQinvCorrFctn("qinvcfkt2pip", 100,0.0,1.0); + cqinvkt2pip->SetPairSelectionCut(ktpairkT2pip); + anpip->AddCorrFctn(cqinvkt2pip); + + AliFemtoQinvCorrFctn *cqinvkt3pip = new AliFemtoQinvCorrFctn("qinvcfkt3pip", 100,0.0,1.0); + cqinvkt3pip->SetPairSelectionCut(ktpairkT3pip); + anpip->AddCorrFctn(cqinvkt3pip); + + // Setting up the model calculation + // First create the freeze-out generator + AliFemtoModelGausLCMSFreezeOutGenerator *tFreezepip = new AliFemtoModelGausLCMSFreezeOutGenerator(); + tFreezepip->SetSizeOut(1.8*TMath::Sqrt(2.0)); + tFreezepip->SetSizeSide(1.3*TMath::Sqrt(2.0)); + tFreezepip->SetSizeLong(1.6*TMath::Sqrt(2.0)); + + // And the weight generator + AliFemtoModelWeightGeneratorBasic *tWeightpip = new AliFemtoModelWeightGeneratorBasic(); + tWeightpip->SetPairType(AliFemtoModelWeightGenerator::PionPlusPionPlus()); + + // Create a manager that will connect it + AliFemtoModelManager *tModelManagerpip = new AliFemtoModelManager(); + tModelManagerpip->AcceptFreezeOutGenerator(tFreezepip); + tModelManagerpip->AcceptWeightGenerator(tWeightpip); + tModelManagerpip->CreateCopyHiddenInfo(kFALSE); + + // Model correlation functions + AliFemtoModelCorrFctn *c1dpipip; + AliFemtoModelBPLCMSCorrFctn *c3dsmallkt1pip; + AliFemtoModelBPLCMSCorrFctn *c3dsmallkt2pip; + AliFemtoModelBPLCMSCorrFctn *c3dsmallkt3pip; + + c1dpipip = new AliFemtoModelCorrFctn("c1dpipip",100,0.0,1.0); + c1dpipip->ConnectToManager(tModelManagerpip); + + c3dsmallkt1pip = new AliFemtoModelBPLCMSCorrFctn("c3dsmallkt1pip",40, -0.4, 0.4); + c3dsmallkt1pip->SetSpecificPairCut(ktpairkT1pip); + c3dsmallkt1pip->ConnectToManager(tModelManagerpip); + + c3dsmallkt2pip = new AliFemtoModelBPLCMSCorrFctn("c3dsmallkt2pip",40, -0.4, 0.4); + c3dsmallkt2pip->SetSpecificPairCut(ktpairkT2pip); + c3dsmallkt2pip->ConnectToManager(tModelManagerpip); + + c3dsmallkt3pip = new AliFemtoModelBPLCMSCorrFctn("c3dsmallkt3pip",40, -0.4, 0.4); + c3dsmallkt3pip->SetSpecificPairCut(ktpairkT3pip); + c3dsmallkt3pip->ConnectToManager(tModelManagerpip); + + AliFemtoModelCorrFctnDirectYlm *cmylmkt1pip = new AliFemtoModelCorrFctnDirectYlm("mcylmkt1pip",3,80,0.0,0.8,1); + cmylmkt1pip->SetPairSelectionCut(ktpairkT1pip); + cmylmkt1pip->ConnectToManager(tModelManagerpip); + + AliFemtoModelCorrFctnDirectYlm *cmylmkt2pip = new AliFemtoModelCorrFctnDirectYlm("mcylmkt2pip",3,80,0.0,0.8,1); + cmylmkt2pip->SetPairSelectionCut(ktpairkT2pip); + cmylmkt2pip->ConnectToManager(tModelManagerpip); + + AliFemtoModelCorrFctnDirectYlm *cmylmkt3pip = new AliFemtoModelCorrFctnDirectYlm("mcylmkt3pip",3,80,0.0,0.8,1); + cmylmkt3pip->SetPairSelectionCut(ktpairkT3pip); + cmylmkt3pip->ConnectToManager(tModelManagerpip); + + // Add correlation functions to the analysis + anpip->AddCorrFctn(csqqinvpip); + anpip->AddCorrFctn(cchiqinvpip); + anpip->AddCorrFctn(cqtpcnclspip); + anpip->AddCorrFctn(c3dsmallkt1pip); + anpip->AddCorrFctn(c3dsmallkt2pip); + anpip->AddCorrFctn(c3dsmallkt3pip); + anpip->AddCorrFctn(c1dpipip); + anpip->AddCorrFctn(cmylmkt1pip); + anpip->AddCorrFctn(cmylmkt2pip); + anpip->AddCorrFctn(cmylmkt3pip); + + Manager->AddAnalysis(anpip); + + // *** End pion-pion (positive) analysis + } + + if (runNegativePions) { + // *** Begin pion-pion (negative) analysis *** + AliFemtoVertexMultAnalysis *anpim = new AliFemtoVertexMultAnalysis(3, -15.6, 15.6, 1, 2, 200000); + anpim->SetNumEventsToMix(10); + anpim->SetMinSizePartCollection(2); + + AliFemtoBasicEventCut* mecpim = new AliFemtoBasicEventCut(); + mecpim->SetEventMult(2,100000); + mecpim->SetVertZPos(-1000,1000); + + AliFemtoESDTrackCut* dtcpim = new AliFemtoESDTrackCut(); + dtcpim->SetPidProbPion(0.2,1.001); + dtcpim->SetPidProbMuon(0.0,1.0); + dtcpim->SetPidProbKaon(0.0,1.0); + dtcpim->SetPidProbProton(0.0,1.0); + dtcpim->SetCharge(1.0); + dtcpim->SetPt(0.15,0.5); + dtcpim->SetRapidity(-0.8,0.8); + dtcpim->SetMass(PionMass); + // Track quality cuts + dtcpim->SetStatus(AliESDtrack::kTPCrefit|AliESDtrack::kITSrefit); + // dtcpim->SetStatus(AliESDtrack::kTPCrefit); + dtcpim->SetminTPCncls(50); + dtcpim->SetRemoveKinks(kTRUE); + dtcpim->SetLabel(kFALSE); + dtcpim->SetMaxITSChiNdof(2.5); + dtcpim->SetMaxTPCChiNdof(3.0); + dtcpim->SetMaxImpactXY(3.0); + dtcpim->SetMaxImpactZ(3.0); + + // Track monitors + AliFemtoCutMonitorParticleYPt *cutPassYPtpim = new AliFemtoCutMonitorParticleYPt("cutPasspim", 0.13957); + AliFemtoCutMonitorParticleYPt *cutFailYPtpim = new AliFemtoCutMonitorParticleYPt("cutFailpim", 0.13957); + dtcpim->AddCutMonitor(cutPassYPtpim, cutFailYPtpim); + + AliFemtoCutMonitorEventMult *cutPassEvMpim = new AliFemtoCutMonitorEventMult("cutPasspim"); + AliFemtoCutMonitorEventMult *cutFailEvMpim = new AliFemtoCutMonitorEventMult("cutFailpim"); + mecpim->AddCutMonitor(cutPassEvMpim, cutFailEvMpim); + + AliFemtoCutMonitorEventVertex *cutPassEvVpim = new AliFemtoCutMonitorEventVertex("cutPasspim"); + AliFemtoCutMonitorEventVertex *cutFailEvVpim = new AliFemtoCutMonitorEventVertex("cutFailpim"); + mecpim->AddCutMonitor(cutPassEvVpim, cutFailEvVpim); + + // Pair cut + AliFemtoShareQualityTPCEntranceSepPairCut *sqpcpim = new AliFemtoShareQualityTPCEntranceSepPairCut(); + sqpcpim->SetShareQualityMax(0.0); + sqpcpim->SetShareFractionMax(0.02); + sqpcpim->SetRemoveSameLabel(kFALSE); + sqpcpim->SetTPCEntranceSepMinimum(2.0); + + anpim->SetEventCut(mecpim); + anpim->SetFirstParticleCut(dtcpim); + anpim->SetSecondParticleCut(dtcpim); + anpim->SetPairCut(sqpcpim); + + // Two-track quality monitoring + AliFemtoShareQualityCorrFctn *csqqinvpim= new AliFemtoShareQualityCorrFctn("sqqinvcfpim",40,0.0,0.4); + AliFemtoChi2CorrFctn *cchiqinvpim= new AliFemtoChi2CorrFctn("chicfpim",40,0.0,0.4); + AliFemtoCorrFctnTPCNcls *cqtpcnclspim = new AliFemtoCorrFctnTPCNcls("cqtpcnclspim",40,0.0,0.4); + + // Intrdouce kT binning + AliFemtoKTPairCut *ktpairkT1pim = new AliFemtoKTPairCut(0.1,0.27); + AliFemtoKTPairCut *ktpairkT2pim = new AliFemtoKTPairCut(0.27,0.37); + AliFemtoKTPairCut *ktpairkT3pim = new AliFemtoKTPairCut(0.37,0.52); + + // Purely experimental correlation function + AliFemtoCorrFctnDirectYlm *cylmkT1pim = new AliFemtoCorrFctnDirectYlm("cylmkT1pim",3,80,0.0,0.8,1); + cylmkT1pim->SetPairSelectionCut(ktpairkT1pim); + anpim->AddCorrFctn(cylmkT1pim); + + AliFemtoCorrFctnDirectYlm *cylmkT2pim = new AliFemtoCorrFctnDirectYlm("cylmkT2pim",3,80,0.0,0.8,1); + cylmkT2pim->SetPairSelectionCut(ktpairkT2pim); + anpim->AddCorrFctn(cylmkT2pim); + + AliFemtoCorrFctnDirectYlm *cylmkT3pim = new AliFemtoCorrFctnDirectYlm("cylmkT3pim",3,80,0.0,0.8,1); + cylmkT3pim->SetPairSelectionCut(ktpairkT3pim); + anpim->AddCorrFctn(cylmkT3pim); + + AliFemtoQinvCorrFctn *cqinvkt1pim = new AliFemtoQinvCorrFctn("qinvcfkt1pim", 100,0.0,1.0); + cqinvkt1pim->SetPairSelectionCut(ktpairkT1pim); + anpim->AddCorrFctn(cqinvkt1pim); + + AliFemtoQinvCorrFctn *cqinvkt2pim = new AliFemtoQinvCorrFctn("qinvcfkt2pim", 100,0.0,1.0); + cqinvkt2pim->SetPairSelectionCut(ktpairkT2pim); + anpim->AddCorrFctn(cqinvkt2pim); + + AliFemtoQinvCorrFctn *cqinvkt3pim = new AliFemtoQinvCorrFctn("qinvcfkt3pim", 100,0.0,1.0); + cqinvkt3pim->SetPairSelectionCut(ktpairkT3pim); + anpim->AddCorrFctn(cqinvkt3pim); + + // Setting up the model calculation + // First create the freeze-out generator + AliFemtoModelGausLCMSFreezeOutGenerator *tFreezepim = new AliFemtoModelGausLCMSFreezeOutGenerator(); + tFreezepim->SetSizeOut(1.8*TMath::Sqrt(2.0)); + tFreezepim->SetSizeSide(1.3*TMath::Sqrt(2.0)); + tFreezepim->SetSizeLong(1.6*TMath::Sqrt(2.0)); + + // And the weight generator + AliFemtoModelWeightGeneratorBasic *tWeightpim = new AliFemtoModelWeightGeneratorBasic(); + tWeightpim->SetPairType(AliFemtoModelWeightGenerator::PionPlusPionPlus()); + + // Create a manager that will connect it + AliFemtoModelManager *tModelManagerpim = new AliFemtoModelManager(); + tModelManagerpim->AcceptFreezeOutGenerator(tFreezepim); + tModelManagerpim->AcceptWeightGenerator(tWeightpim); + tModelManagerpim->CreateCopyHiddenInfo(kFALSE); + + // Model correlation functions + AliFemtoModelCorrFctn *c1dpipim; + AliFemtoModelBPLCMSCorrFctn *c3dsmallkt1pim; + AliFemtoModelBPLCMSCorrFctn *c3dsmallkt2pim; + AliFemtoModelBPLCMSCorrFctn *c3dsmallkt3pim; + + c1dpipim = new AliFemtoModelCorrFctn("c1dpipim",100,0.0,1.0); + c1dpipim->ConnectToManager(tModelManagerpim); + + c3dsmallkt1pim = new AliFemtoModelBPLCMSCorrFctn("c3dsmallkt1pim",40, -0.4, 0.4); + c3dsmallkt1pim->SetSpecificPairCut(ktpairkT1pim); + c3dsmallkt1pim->ConnectToManager(tModelManagerpim); + + c3dsmallkt2pim = new AliFemtoModelBPLCMSCorrFctn("c3dsmallkt2pim",40, -0.4, 0.4); + c3dsmallkt2pim->SetSpecificPairCut(ktpairkT2pim); + c3dsmallkt2pim->ConnectToManager(tModelManagerpim); + + c3dsmallkt3pim = new AliFemtoModelBPLCMSCorrFctn("c3dsmallkt3pim",40, -0.4, 0.4); + c3dsmallkt3pim->SetSpecificPairCut(ktpairkT3pim); + c3dsmallkt3pim->ConnectToManager(tModelManagerpim); + + AliFemtoModelCorrFctnDirectYlm *cmylmkt1pim = new AliFemtoModelCorrFctnDirectYlm("mcylmkt1pim",3,80,0.0,0.8,1); + cmylmkt1pim->SetPairSelectionCut(ktpairkT1pim); + cmylmkt1pim->ConnectToManager(tModelManagerpim); + + AliFemtoModelCorrFctnDirectYlm *cmylmkt2pim = new AliFemtoModelCorrFctnDirectYlm("mcylmkt2pim",3,80,0.0,0.8,1); + cmylmkt2pim->SetPairSelectionCut(ktpairkT2pim); + cmylmkt2pim->ConnectToManager(tModelManagerpim); + + AliFemtoModelCorrFctnDirectYlm *cmylmkt3pim = new AliFemtoModelCorrFctnDirectYlm("mcylmkt3pim",3,80,0.0,0.8,1); + cmylmkt3pim->SetPairSelectionCut(ktpairkT3pim); + cmylmkt3pim->ConnectToManager(tModelManagerpim); + + // Add correlation functions to the analysis + anpim->AddCorrFctn(csqqinvpim); + anpim->AddCorrFctn(cchiqinvpim); + anpim->AddCorrFctn(cqtpcnclspim); + anpim->AddCorrFctn(c3dsmallkt1pim); + anpim->AddCorrFctn(c3dsmallkt2pim); + anpim->AddCorrFctn(c3dsmallkt3pim); + anpim->AddCorrFctn(c1dpipim); + anpim->AddCorrFctn(cmylmkt1pim); + anpim->AddCorrFctn(cmylmkt2pim); + anpim->AddCorrFctn(cmylmkt3pim); + + Manager->AddAnalysis(anpim); + + // *** End pion-pion (negative) analysis + } + + if (runPositiveKaons) { + // *** Begin Kaon-Kaon (positive) analysis + AliFemtoVertexMultAnalysis *ankp = new AliFemtoVertexMultAnalysis(10, -15.6, 15.6, 1, 2, 20000); + ankp->SetNumEventsToMix(10); + ankp->SetMinSizePartCollection(2); + + AliFemtoBasicEventCut* meckp = new AliFemtoBasicEventCut(); + meckp->SetEventMult(1,100000); + meckp->SetVertZPos(-1000,1000); + + AliFemtoESDTrackCut* dtckp = new AliFemtoESDTrackCut(); + dtckp->SetPidProbKaon(0.7,1.001); + dtckp->SetPidProbMuon(0.0,0.5); + dtckp->SetPidProbPion(0.0,0.5); + dtckp->SetPidProbProton(0.0,0.5); + dtckp->SetCharge(1.0); + dtckp->SetMostProbableKaon(); + dtckp->SetPt(0.15,2.0); + dtckp->SetMass(KaonMass); + dtckp->SetRapidity(-0.8,0.8); + // Track quality cuts + dtckp->SetStatus(AliESDtrack::kTPCrefit|AliESDtrack::kITSrefit); + //dtckp->SetStatus(AliESDtrack::kTPCrefit); + // dtckp->SetminTPCclsF(95); + dtckp->SetminTPCncls(50); + dtckp->SetRemoveKinks(kTRUE); + dtckp->SetLabel(kFALSE); + dtckp->SetMaxITSChiNdof(2.5); + dtckp->SetMaxTPCChiNdof(3.0); + // dtckp->SetMaxSigmaToVertex(3.0); + dtckp->SetMaxImpactXY(3.0); + dtckp->SetMaxImpactZ(3.0); + + AliFemtoCutMonitorParticleYPt *cutPassYPtkp = new AliFemtoCutMonitorParticleYPt("cutPasskp", 0.493677); + AliFemtoCutMonitorParticleYPt *cutFailYPtkp = new AliFemtoCutMonitorParticleYPt("cutFailkp", 0.493677); + dtckp->AddCutMonitor(cutPassYPtkp, cutFailYPtkp); + + AliFemtoCutMonitorParticlePtPDG *cutPassPidkp = new AliFemtoCutMonitorParticlePtPDG("cutPasskp", 0.493677); + AliFemtoCutMonitorParticlePtPDG *cutFailPidkp = new AliFemtoCutMonitorParticlePtPDG("cutFailkp", 0.493677); + dtckp->AddCutMonitor(cutPassPidkp, cutFailPidkp); + + AliFemtoCutMonitorParticleMomRes *cutPassMRkp = new AliFemtoCutMonitorParticleMomRes("cutPasskp"); + AliFemtoCutMonitorParticleMomRes *cutFailMRkp = new AliFemtoCutMonitorParticleMomRes("cutFailkp"); + dtckp->AddCutMonitor(cutPassMRkp, cutFailMRkp); + + AliFemtoCutMonitorParticleVertPos *cutPassVPkp = new AliFemtoCutMonitorParticleVertPos("cutPasskp"); + AliFemtoCutMonitorParticleVertPos *cutFailVPkp = new AliFemtoCutMonitorParticleVertPos("cutFailkp"); + dtckp->AddCutMonitor(cutPassVPkp, cutFailVPkp); + + AliFemtoCutMonitorEventMult *cutPassEvMkp = new AliFemtoCutMonitorEventMult("cutPasskp"); + AliFemtoCutMonitorEventMult *cutFailEvMkp = new AliFemtoCutMonitorEventMult("cutFailkp"); + meckp->AddCutMonitor(cutPassEvMkp, cutFailEvMkp); + + AliFemtoCutMonitorEventVertex *cutPassEvVkp = new AliFemtoCutMonitorEventVertex("cutPasskp"); + AliFemtoCutMonitorEventVertex *cutFailEvVkp = new AliFemtoCutMonitorEventVertex("cutFailkp"); + meckp->AddCutMonitor(cutPassEvVkp, cutFailEvVkp); + + AliFemtoShareQualityTPCEntranceSepPairCut *sqpckp = new AliFemtoShareQualityTPCEntranceSepPairCut(); + sqpckp->SetShareQualityMax(0.0); + sqpckp->SetShareFractionMax(0.02); + sqpckp->SetRemoveSameLabel(kFALSE); + sqpckp->SetTPCEntranceSepMinimum(3.0); + + ankp->SetEventCut(meckp); + ankp->SetFirstParticleCut(dtckp); + ankp->SetSecondParticleCut(dtckp); + ankp->SetPairCut(sqpckp); + + AliFemtoQinvCorrFctn *cqinvkp= new AliFemtoQinvCorrFctn("qinvcf",100,0.0,1.0); + + AliFemtoModelBPLCMSCorrFctn *c3dsmallkp; + AliFemtoModelCorrFctn *c1dpikp; + + // Setting up the model calculation + // First create the freeze-out generator + AliFemtoModelGausRinvFreezeOutGenerator *tFreezekp = new AliFemtoModelGausRinvFreezeOutGenerator(); + tFreezekp->SetSizeInv(1.8*TMath::Sqrt(2.0)); + tFreezekp->SetSelectPrimaryFromHidden(false); + + // And the weight generator + // AliFemtoModelWeightGeneratorBasic *tWeightkp = new AliFemtoModelWeightGeneratorBasic(); + // tWeightkp->SetPairType(AliFemtoModelWeightGenerator::KaonPlusKaonPlus()); + AliFemtoModelWeightGeneratorLednicky *tWeightkp = new AliFemtoModelWeightGeneratorLednicky(); + tWeightkp->SetPairType(AliFemtoModelWeightGenerator::KaonPlusKaonPlus()); + tWeightkp->SetCoulOn(); + tWeightkp->SetQuantumOn(); + tWeightkp->SetStrongOff(); + tWeightkp->Set3BodyOff(); + + // Create a manager that will connect it + AliFemtoModelManager *tModelManagerkp = new AliFemtoModelManager(); + tModelManagerkp->AcceptFreezeOutGenerator(tFreezekp); + tModelManagerkp->AcceptWeightGenerator(tWeightkp); + tModelManagerkp->CreateCopyHiddenInfo(kFALSE); + + c3dsmallkp = new AliFemtoModelBPLCMSCorrFctn("c3dsmallkp",30, 0.0, 0.6); + c3dsmallkp->ConnectToManager(tModelManagerkp); + + c1dpikp = new AliFemtoModelCorrFctn("c1dpikp",100,0.0,1.0); + c1dpikp->ConnectToManager(tModelManagerkp); + + //### + ankp->AddCorrFctn(cqinvkp); + + ankp->AddCorrFctn(c3dsmallkp); + ankp->AddCorrFctn(c1dpikp); + + Manager->AddAnalysis(ankp); + + // *** End Kaon-Kaon (positive) analysis + } + + if (runNegativeKaons) { + // *** Begin Kaon-Kaon (negative) analysis + AliFemtoVertexMultAnalysis *ankm = new AliFemtoVertexMultAnalysis(10, -15.6, 15.6, 1, 2, 20000); + ankm->SetNumEventsToMix(10); + ankm->SetMinSizePartCollection(2); + + AliFemtoBasicEventCut* meckm = new AliFemtoBasicEventCut(); + meckm->SetEventMult(1,100000); + meckm->SetVertZPos(-1000,1000); + + AliFemtoESDTrackCut* dtckm = new AliFemtoESDTrackCut(); + dtckm->SetPidProbKaon(0.7,1.001); + dtckm->SetPidProbMuon(0.0,0.5); + dtckm->SetPidProbPion(0.0,0.5); + dtckm->SetPidProbProton(0.0,0.5); + dtckm->SetCharge(1.0); + dtckm->SetMostProbableKaon(); + dtckm->SetPt(0.15,2.0); + dtckm->SetMass(KaonMass); + dtckm->SetRapidity(-0.8,0.8); + // Track quality cuts + dtckm->SetStatus(AliESDtrack::kTPCrefit|AliESDtrack::kITSrefit); + //dtckm->SetStatus(AliESDtrack::kTPCrefit); + // dtckm->SetminTPCclsF(95); + dtckm->SetminTPCncls(50); + dtckm->SetRemoveKinks(kTRUE); + dtckm->SetLabel(kFALSE); + dtckm->SetMaxITSChiNdof(2.5); + dtckm->SetMaxTPCChiNdof(3.0); + // dtckm->SetMaxSigmaToVertex(3.0); + dtckm->SetMaxImpactXY(3.0); + dtckm->SetMaxImpactZ(3.0); + + AliFemtoCutMonitorParticleYPt *cutPassYPtkm = new AliFemtoCutMonitorParticleYPt("cutPasskm", 0.493677); + AliFemtoCutMonitorParticleYPt *cutFailYPtkm = new AliFemtoCutMonitorParticleYPt("cutFailkm", 0.493677); + dtckm->AddCutMonitor(cutPassYPtkm, cutFailYPtkm); + + AliFemtoCutMonitorParticlePtPDG *cutPassPidkm = new AliFemtoCutMonitorParticlePtPDG("cutPasskm", 0.493677); + AliFemtoCutMonitorParticlePtPDG *cutFailPidkm = new AliFemtoCutMonitorParticlePtPDG("cutFailkm", 0.493677); + dtckm->AddCutMonitor(cutPassPidkm, cutFailPidkm); + + AliFemtoCutMonitorParticleMomRes *cutPassMRkm = new AliFemtoCutMonitorParticleMomRes("cutPasskm"); + AliFemtoCutMonitorParticleMomRes *cutFailMRkm = new AliFemtoCutMonitorParticleMomRes("cutFailkm"); + dtckm->AddCutMonitor(cutPassMRkm, cutFailMRkm); + + AliFemtoCutMonitorParticleVertPos *cutPassVPkm = new AliFemtoCutMonitorParticleVertPos("cutPasskm"); + AliFemtoCutMonitorParticleVertPos *cutFailVPkm = new AliFemtoCutMonitorParticleVertPos("cutFailkm"); + dtckm->AddCutMonitor(cutPassVPkm, cutFailVPkm); + + AliFemtoCutMonitorEventMult *cutPassEvMkm = new AliFemtoCutMonitorEventMult("cutPasskm"); + AliFemtoCutMonitorEventMult *cutFailEvMkm = new AliFemtoCutMonitorEventMult("cutFailkm"); + meckm->AddCutMonitor(cutPassEvMkm, cutFailEvMkm); + + AliFemtoCutMonitorEventVertex *cutPassEvVkm = new AliFemtoCutMonitorEventVertex("cutPasskm"); + AliFemtoCutMonitorEventVertex *cutFailEvVkm = new AliFemtoCutMonitorEventVertex("cutFailkm"); + meckm->AddCutMonitor(cutPassEvVkm, cutFailEvVkm); + + AliFemtoShareQualityTPCEntranceSepPairCut *sqpckm = new AliFemtoShareQualityTPCEntranceSepPairCut(); + sqpckm->SetShareQualityMax(0.0); + sqpckm->SetShareFractionMax(0.02); + sqpckm->SetRemoveSameLabel(kFALSE); + sqpckm->SetTPCEntranceSepMinimum(3.0); + + ankm->SetEventCut(meckm); + ankm->SetFirstParticleCut(dtckm); + ankm->SetSecondParticleCut(dtckm); + ankm->SetPairCut(sqpckm); + + AliFemtoQinvCorrFctn *cqinvkm= new AliFemtoQinvCorrFctn("qinvcf",100,0.0,1.0); + + AliFemtoModelBPLCMSCorrFctn *c3dsmallkm; + AliFemtoModelCorrFctn *c1dpikm; + + // Setting up the model calculation + // First create the freeze-out generator + AliFemtoModelGausRinvFreezeOutGenerator *tFreezekm = new AliFemtoModelGausRinvFreezeOutGenerator(); + tFreezekm->SetSizeInv(1.8*TMath::Sqrt(2.0)); + tFreezekm->SetSelectPrimaryFromHidden(false); + + // And the weight generator + // AliFemtoModelWeightGeneratorBasic *tWeightkm = new AliFemtoModelWeightGeneratorBasic(); + // tWeightkm->SetPairType(AliFemtoModelWeightGenerator::KaonPlusKaonPlus()); + AliFemtoModelWeightGeneratorLednicky *tWeightkm = new AliFemtoModelWeightGeneratorLednicky(); + tWeightkm->SetPairType(AliFemtoModelWeightGenerator::KaonPlusKaonPlus()); + tWeightkm->SetCoulOn(); + tWeightkm->SetQuantumOn(); + tWeightkm->SetStrongOff(); + tWeightkm->Set3BodyOff(); + + // Create a manager that will connect it + AliFemtoModelManager *tModelManagerkm = new AliFemtoModelManager(); + tModelManagerkm->AcceptFreezeOutGenerator(tFreezekm); + tModelManagerkm->AcceptWeightGenerator(tWeightkm); + tModelManagerkm->CreateCopyHiddenInfo(kFALSE); + + c3dsmallkm = new AliFemtoModelBPLCMSCorrFctn("c3dsmallkm",30, 0.0, 0.6); + c3dsmallkm->ConnectToManager(tModelManagerkm); + + c1dpikm = new AliFemtoModelCorrFctn("c1dpikm",100,0.0,1.0); + c1dpikm->ConnectToManager(tModelManagerkm); + + //### + ankm->AddCorrFctn(cqinvkm); + + ankm->AddCorrFctn(c3dsmallkm); + ankm->AddCorrFctn(c1dpikm); + + Manager->AddAnalysis(ankm); + + // *** End Kaon-Kaon (positive) analysis + } + return Manager; +} +