From 0b3bd1acc8fd5d5136d8d82aa4fc37fba36d5f44 Mon Sep 17 00:00:00 2001 From: akisiel Date: Tue, 5 Feb 2008 16:51:41 +0000 Subject: [PATCH] Bring AliFemto up to date with latest code developements - Update autmatic generation of output histogram list - Add cuts, monitors and correlation functions for various TPC quality information (exit point, entrance point, track quality, momentum resolution, TPC-only momentum) - Add readers for new ESD - Add readers for Kinematics information with the new ESD - Update model code to use true PID for weight generation - Add code to calculate correlation functions for non-identical particles - Add basic examples for track and particle monitors --- PWG2/FEMTOSCOPY/AliFemto/AliFemtoAnalysis.h | 1 + .../AliFemto/AliFemtoBPLCMS3DCorrFctn.cxx | 12 + .../AliFemto/AliFemtoBPLCMS3DCorrFctn.h | 1 + PWG2/FEMTOSCOPY/AliFemto/AliFemtoCorrFctn.h | 2 + .../AliFemto/AliFemtoCorrFctnNonIdDR.cxx | 271 ++++++ .../AliFemto/AliFemtoCorrFctnNonIdDR.h | 54 ++ PWG2/FEMTOSCOPY/AliFemto/AliFemtoCutMonitor.h | 3 + .../AliFemto/AliFemtoCutMonitorHandler.cxx | 29 + .../AliFemto/AliFemtoCutMonitorHandler.h | 2 + .../AliFemtoCutMonitorParticleYPt.cxx | 87 ++ .../AliFemto/AliFemtoCutMonitorParticleYPt.h | 43 + .../AliFemto/AliFemtoDummyPairCut.cxx | 11 +- .../AliFemto/AliFemtoDummyPairCut.h | 7 +- .../AliFemto/AliFemtoEventReaderESD.cxx | 12 + .../AliFemto/AliFemtoEventReaderESDChain.cxx | 91 +- .../AliFemto/AliFemtoEventReaderESDChain.h | 2 + .../AliFemtoEventReaderESDChainKine.cxx | 296 +++++++ .../AliFemtoEventReaderESDChainKine.h | 61 ++ .../FEMTOSCOPY/AliFemto/AliFemtoKTPairCut.cxx | 99 +++ PWG2/FEMTOSCOPY/AliFemto/AliFemtoKTPairCut.h | 57 ++ PWG2/FEMTOSCOPY/AliFemto/AliFemtoKink.cxx | 29 +- PWG2/FEMTOSCOPY/AliFemto/AliFemtoKink.h | 23 +- .../AliFemto/AliFemtoLikeSignCorrFctn.h | 1 + PWG2/FEMTOSCOPY/AliFemto/AliFemtoManager.h | 1 - .../AliFemto/AliFemtoModelCorrFctn.cxx | 11 + .../AliFemto/AliFemtoModelCorrFctn.h | 3 +- .../AliFemto/AliFemtoModelHiddenInfo.cxx | 13 +- .../AliFemto/AliFemtoModelWeightGenerator.cxx | 34 +- .../AliFemto/AliFemtoModelWeightGenerator.h | 4 + .../AliFemtoModelWeightGeneratorBasic.cxx | 24 +- PWG2/FEMTOSCOPY/AliFemto/AliFemtoPair.cxx | 756 ++++++++--------- PWG2/FEMTOSCOPY/AliFemto/AliFemtoPair.h | 228 ++--- PWG2/FEMTOSCOPY/AliFemto/AliFemtoParticle.cxx | 780 +++++++++--------- PWG2/FEMTOSCOPY/AliFemto/AliFemtoParticle.h | 38 +- .../AliFemto/AliFemtoQinvCorrFctn.cxx | 17 + .../AliFemto/AliFemtoQinvCorrFctn.h | 3 + .../AliFemto/AliFemtoSimpleAnalysis.cxx | 45 + .../AliFemto/AliFemtoSimpleAnalysis.h | 3 +- PWG2/FEMTOSCOPY/AliFemto/AliFemtoTrack.cxx | 66 ++ PWG2/FEMTOSCOPY/AliFemto/AliFemtoTrack.h | 19 +- .../AliFemtoUser/AliFemtoChi2CorrFctn.cxx | 332 ++++++++ .../AliFemtoUser/AliFemtoChi2CorrFctn.h | 57 ++ .../AliFemtoCutMonitorParticleMomRes.cxx | 178 ++++ .../AliFemtoCutMonitorParticleMomRes.h | 50 ++ .../AliFemtoCutMonitorParticleYPt.cxx | 79 ++ .../AliFemtoCutMonitorParticleYPt.h | 40 + .../AliFemtoUser/AliFemtoESDTrackCut.cxx | 36 +- .../AliFemtoUser/AliFemtoESDTrackCut.h | 13 + .../AliFemtoEventReaderESDKine.cxx | 78 +- .../AliFemtoUser/AliFemtoEventReaderESDKine.h | 3 + .../AliFemtoModelBPLCMSCorrFctn.cxx | 70 +- .../AliFemtoModelBPLCMSCorrFctn.h | 13 +- .../AliFemtoModelCorrFctnSource.cxx | 14 + .../AliFemtoModelCorrFctnSource.h | 1 + .../AliFemtoModelCorrFctnTrueQ.cxx | 138 ++++ .../AliFemtoUser/AliFemtoModelCorrFctnTrueQ.h | 49 ++ .../AliFemtoShareQualityCorrFctn.cxx | 108 ++- .../AliFemtoShareQualityCorrFctn.h | 1 + .../AliFemtoShareQualityKTPairCut.cxx | 101 +++ .../AliFemtoShareQualityKTPairCut.h | 51 ++ .../AliFemtoShareQualityPairCut.h | 4 +- ...FemtoShareQualityTPCEntranceSepPairCut.cxx | 97 +++ ...liFemtoShareQualityTPCEntranceSepPairCut.h | 58 ++ .../AliFemtoUser/AliFemtoTPCInnerCorrFctn.cxx | 141 ++++ .../AliFemtoUser/AliFemtoTPCInnerCorrFctn.h | 45 + PWG2/PWG2femtoscopyLinkDef.h | 4 + PWG2/PWG2femtoscopyUserLinkDef.h | 7 + PWG2/libPWG2femtoscopy.pkg | 7 +- PWG2/libPWG2femtoscopyUser.pkg | 9 +- 69 files changed, 3965 insertions(+), 1058 deletions(-) create mode 100644 PWG2/FEMTOSCOPY/AliFemto/AliFemtoCorrFctnNonIdDR.cxx create mode 100644 PWG2/FEMTOSCOPY/AliFemto/AliFemtoCorrFctnNonIdDR.h create mode 100644 PWG2/FEMTOSCOPY/AliFemto/AliFemtoCutMonitorParticleYPt.cxx create mode 100644 PWG2/FEMTOSCOPY/AliFemto/AliFemtoCutMonitorParticleYPt.h create mode 100644 PWG2/FEMTOSCOPY/AliFemto/AliFemtoEventReaderESDChainKine.cxx create mode 100644 PWG2/FEMTOSCOPY/AliFemto/AliFemtoEventReaderESDChainKine.h create mode 100644 PWG2/FEMTOSCOPY/AliFemto/AliFemtoKTPairCut.cxx create mode 100644 PWG2/FEMTOSCOPY/AliFemto/AliFemtoKTPairCut.h create mode 100644 PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoChi2CorrFctn.cxx create mode 100644 PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoChi2CorrFctn.h create mode 100644 PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoCutMonitorParticleMomRes.cxx create mode 100644 PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoCutMonitorParticleMomRes.h create mode 100644 PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoCutMonitorParticleYPt.cxx create mode 100644 PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoCutMonitorParticleYPt.h create mode 100644 PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoModelCorrFctnTrueQ.cxx create mode 100644 PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoModelCorrFctnTrueQ.h create mode 100644 PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityKTPairCut.cxx create mode 100644 PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityKTPairCut.h create mode 100644 PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityTPCEntranceSepPairCut.cxx create mode 100644 PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityTPCEntranceSepPairCut.h create mode 100644 PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoTPCInnerCorrFctn.cxx create mode 100644 PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoTPCInnerCorrFctn.h diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoAnalysis.h b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoAnalysis.h index 898e66fa7d4..2a74d274da0 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoAnalysis.h +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoAnalysis.h @@ -22,6 +22,7 @@ public: virtual AliFemtoString Report() = 0; //! returns reports of all cuts applied and correlation functions being done virtual TList* ListSettings() = 0; // return list of cut settings for the analysis + virtual TList* GetOutputList() = 0; // Return a TList of objects to be written as output virtual void ProcessEvent(const AliFemtoEvent* aEventToAnalyze) = 0; virtual void Finish() = 0; diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoBPLCMS3DCorrFctn.cxx b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoBPLCMS3DCorrFctn.cxx index 04e498a5bfa..de061948b76 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoBPLCMS3DCorrFctn.cxx +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoBPLCMS3DCorrFctn.cxx @@ -265,6 +265,18 @@ void AliFemtoBPLCMS3DCorrFctn::WriteOutHistos(){ } */ } +//______________________________ +TList* AliFemtoBPLCMS3DCorrFctn::GetOutputList() +{ + // Prepare the list of objects to be written to the output + TList *tOutputList = new TList(); + + tOutputList->Add(fNumerator); + tOutputList->Add(fDenominator); + tOutputList->Add(fQinvHisto); + + return tOutputList; +} //_________________________ void AliFemtoBPLCMS3DCorrFctn::Finish(){ diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoBPLCMS3DCorrFctn.h b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoBPLCMS3DCorrFctn.h index 226546d2d57..d1e5debc81d 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoBPLCMS3DCorrFctn.h +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoBPLCMS3DCorrFctn.h @@ -43,6 +43,7 @@ public: float GetNormRangeHi() const; void WriteOutHistos(); + virtual TList* GetOutputList(); // void SetCoulombCorrection(AliFemtoCoulomb* Correction); diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoCorrFctn.h b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoCorrFctn.h index 0423e6d2d79..d4c5565f282 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoCorrFctn.h +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoCorrFctn.h @@ -28,6 +28,8 @@ public: virtual void EventEnd(const AliFemtoEvent* aEvent) { /* no-op */ } virtual void Finish() = 0; + virtual TList* GetOutputList() = 0; + virtual AliFemtoCorrFctn* Clone() { return 0;} AliFemtoAnalysis* HbtAnalysis(){return fyAnalysis;}; diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoCorrFctnNonIdDR.cxx b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoCorrFctnNonIdDR.cxx new file mode 100644 index 00000000000..c13b4b61efa --- /dev/null +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoCorrFctnNonIdDR.cxx @@ -0,0 +1,271 @@ +//////////////////////////////////////////////////////////////////////////////// +// // +// AliFemtoCorrFctnNonIdDR - correlation function for non-identical particles // +// uses k* as a function variable. Stores the correlation function separately // +// for positive and negative signs of k* projections into out, side and long // +// directions, enabling the calculations of double ratios // +// // +//////////////////////////////////////////////////////////////////////////////// + +#include "AliFemtoCorrFctnNonIdDR.h" +//#include "AliFemtoHisto.h" +#include + +#ifdef __ROOT__ +ClassImp(AliFemtoCorrFctnNonIdDR) +#endif + +//____________________________ +AliFemtoCorrFctnNonIdDR::AliFemtoCorrFctnNonIdDR(char* title, const int& nbins, const float& QinvLo, const float& QinvHi): + fNumOutP(0), + fNumOutN(0), + fNumSideP(0), + fNumSideN(0), + fNumLongP(0), + fNumLongN(0), + fDenOutP(0), + fDenOutN(0), + fDenSideP(0), + fDenSideN(0), + fDenLongP(0), + fDenLongN(0) +{ + // Default constructor + // set up numerators + char bufname[200]; + snprintf(bufname, 200, "NumOutP%s", title); + fNumOutP = new TH1D(bufname,title,nbins,QinvLo,QinvHi); + snprintf(bufname, 200, "NumOutN%s", title); + fNumOutN = new TH1D(bufname,title,nbins,QinvLo,QinvHi); + snprintf(bufname, 200, "NumSideP%s", title); + fNumSideP = new TH1D(bufname,title,nbins,QinvLo,QinvHi); + snprintf(bufname, 200, "NumSideN%s", title); + fNumSideN = new TH1D(bufname,title,nbins,QinvLo,QinvHi); + snprintf(bufname, 200, "NumLongP%s", title); + fNumLongP = new TH1D(bufname,title,nbins,QinvLo,QinvHi); + snprintf(bufname, 200, "NumLongN%s", title); + fNumLongN = new TH1D(bufname,title,nbins,QinvLo,QinvHi); + + // set up denominators + snprintf(bufname, 200, "DenOutP%s", title); + fDenOutP = new TH1D(bufname,title,nbins,QinvLo,QinvHi); + snprintf(bufname, 200, "DenOutN%s", title); + fDenOutN = new TH1D(bufname,title,nbins,QinvLo,QinvHi); + snprintf(bufname, 200, "DenSideP%s", title); + fDenSideP = new TH1D(bufname,title,nbins,QinvLo,QinvHi); + snprintf(bufname, 200, "DenSideN%s", title); + fDenSideN = new TH1D(bufname,title,nbins,QinvLo,QinvHi); + snprintf(bufname, 200, "DenLongP%s", title); + fDenLongP = new TH1D(bufname,title,nbins,QinvLo,QinvHi); + snprintf(bufname, 200, "DenLongN%s", title); + fDenLongN = new TH1D(bufname,title,nbins,QinvLo,QinvHi); + + // to enable error bar calculation... + fNumOutP->Sumw2(); + fNumOutN->Sumw2(); + fNumSideP->Sumw2(); + fNumSideN->Sumw2(); + fNumLongP->Sumw2(); + fNumLongN->Sumw2(); + fDenOutP->Sumw2(); + fDenOutN->Sumw2(); + fDenSideP->Sumw2(); + fDenSideN->Sumw2(); + fDenLongP->Sumw2(); + fDenLongN->Sumw2(); +} + +//____________________________ +AliFemtoCorrFctnNonIdDR::AliFemtoCorrFctnNonIdDR(const AliFemtoCorrFctnNonIdDR& aCorrFctn) : + fNumOutP(0), + fNumOutN(0), + fNumSideP(0), + fNumSideN(0), + fNumLongP(0), + fNumLongN(0), + fDenOutP(0), + fDenOutN(0), + fDenSideP(0), + fDenSideN(0), + fDenLongP(0), + fDenLongN(0) +{ + // copy constructor + if (aCorrFctn.fNumOutP) + fNumOutP = new TH1D(*aCorrFctn.fNumOutP); + if (aCorrFctn.fNumOutN) + fNumOutN = new TH1D(*aCorrFctn.fNumOutN); + if (aCorrFctn.fNumSideP) + fNumSideP = new TH1D(*aCorrFctn.fNumSideP); + if (aCorrFctn.fNumSideN) + fNumSideN = new TH1D(*aCorrFctn.fNumSideN); + if (aCorrFctn.fNumLongP) + fNumLongP = new TH1D(*aCorrFctn.fNumLongP); + if (aCorrFctn.fNumLongN) + fNumLongN = new TH1D(*aCorrFctn.fNumLongN); + + if (aCorrFctn.fDenOutP) + fDenOutP = new TH1D(*aCorrFctn.fDenOutP); + if (aCorrFctn.fDenOutN) + fDenOutN = new TH1D(*aCorrFctn.fDenOutN); + if (aCorrFctn.fDenSideP) + fDenSideP = new TH1D(*aCorrFctn.fDenSideP); + if (aCorrFctn.fDenSideN) + fDenSideN = new TH1D(*aCorrFctn.fDenSideN); + if (aCorrFctn.fDenLongP) + fDenLongP = new TH1D(*aCorrFctn.fDenLongP); + if (aCorrFctn.fDenLongN) + fDenLongN = new TH1D(*aCorrFctn.fDenLongN); +} +//____________________________ +AliFemtoCorrFctnNonIdDR::~AliFemtoCorrFctnNonIdDR(){ + delete fNumOutP; + delete fNumOutN; + delete fNumSideP; + delete fNumSideN; + delete fNumLongP; + delete fNumLongN; + delete fDenOutP; + delete fDenOutN; + delete fDenSideP; + delete fDenSideN; + delete fDenLongP; + delete fDenLongN; +} +//_________________________ +AliFemtoCorrFctnNonIdDR& AliFemtoCorrFctnNonIdDR::operator=(const AliFemtoCorrFctnNonIdDR& aCorrFctn) +{ + // assignment operator + if (this == &aCorrFctn) + return *this; + + if (aCorrFctn.fNumOutP) + fNumOutP = new TH1D(*aCorrFctn.fNumOutP); + if (aCorrFctn.fNumOutN) + fNumOutN = new TH1D(*aCorrFctn.fNumOutN); + if (aCorrFctn.fNumSideP) + fNumSideP = new TH1D(*aCorrFctn.fNumSideP); + if (aCorrFctn.fNumSideN) + fNumSideN = new TH1D(*aCorrFctn.fNumSideN); + if (aCorrFctn.fNumLongP) + fNumLongP = new TH1D(*aCorrFctn.fNumLongP); + if (aCorrFctn.fNumLongN) + fNumLongN = new TH1D(*aCorrFctn.fNumLongN); + + if (aCorrFctn.fDenOutP) + fDenOutP = new TH1D(*aCorrFctn.fDenOutP); + if (aCorrFctn.fDenOutN) + fDenOutN = new TH1D(*aCorrFctn.fDenOutN); + if (aCorrFctn.fDenSideP) + fDenSideP = new TH1D(*aCorrFctn.fDenSideP); + if (aCorrFctn.fDenSideN) + fDenSideN = new TH1D(*aCorrFctn.fDenSideN); + if (aCorrFctn.fDenLongP) + fDenLongP = new TH1D(*aCorrFctn.fDenLongP); + if (aCorrFctn.fDenLongN) + fDenLongN = new TH1D(*aCorrFctn.fDenLongN); + + return *this; +} + +//_________________________ +void AliFemtoCorrFctnNonIdDR::Finish(){ + // here is where we should normalize, fit, etc... + // we should NOT Draw() the histos (as I had done it below), + // since we want to insulate ourselves from root at this level + // of the code. Do it instead at root command line with browser. + // fNumerator->Draw(); + //fDenominator->Draw(); + //fRatio->Draw(); + // fRatio->Divide(fNumerator,fDenominator,1.0,1.0); + +} + +//____________________________ +AliFemtoString AliFemtoCorrFctnNonIdDR::Report(){ + // construct report + string stemp = "Non-identical particles Correlation Function Report:\n"; + char ctemp[100]; + sprintf(ctemp,"Number of entries in numerators:\t%E\n",fNumOutP->GetEntries()+fNumOutN->GetEntries()); + stemp += ctemp; + sprintf(ctemp,"Number of entries in denominators:\t%E\n",fDenOutP->GetEntries()+fDenOutN->GetEntries()); + stemp += ctemp; + // stemp += mCoulombWeight->Report(); + AliFemtoString returnThis = stemp; + return returnThis; +} +//____________________________ +void AliFemtoCorrFctnNonIdDR::AddRealPair(AliFemtoPair* pair){ + // add true pair + double tKStar = pair->KStar(); + if (pair->KOut()>0.0) + fNumOutP->Fill(tKStar); + else + fNumOutN->Fill(tKStar); + + if (pair->KSide()>0.0) + fNumSideP->Fill(tKStar); + else + fNumSideN->Fill(tKStar); + + if (pair->KLong()>0.0) + fNumLongP->Fill(tKStar); + else + fNumLongN->Fill(tKStar); + +} +//____________________________ +void AliFemtoCorrFctnNonIdDR::AddMixedPair(AliFemtoPair* pair){ + // add mixed (background) pair + double tKStar = pair->KStar(); + if (pair->KOut()>0.0) + fDenOutP->Fill(tKStar); + else + fDenOutN->Fill(tKStar); + + if (pair->KSide()>0.0) + fDenSideP->Fill(tKStar); + else + fDenSideN->Fill(tKStar); + + if (pair->KLong()>0.0) + fDenLongP->Fill(tKStar); + else + fDenLongN->Fill(tKStar); +} +//____________________________ +void AliFemtoCorrFctnNonIdDR::Write(){ + fNumOutP->Write(); + fNumOutN->Write(); + fNumSideP->Write(); + fNumSideN->Write(); + fNumLongP->Write(); + fNumLongN->Write(); + fDenOutP->Write(); + fDenOutN->Write(); + fDenSideP->Write(); + fDenSideN->Write(); + fDenLongP->Write(); + fDenLongN->Write(); +} + +TList* AliFemtoCorrFctnNonIdDR::GetOutputList() +{ + // Prepare the list of objects to be written to the output + TList *tOutputList = new TList(); + + tOutputList->Add(fNumOutP); + tOutputList->Add(fNumOutN); + tOutputList->Add(fNumSideP); + tOutputList->Add(fNumSideN); + tOutputList->Add(fNumLongP); + tOutputList->Add(fNumLongN); + tOutputList->Add(fDenOutP); + tOutputList->Add(fDenOutN); + tOutputList->Add(fDenSideP); + tOutputList->Add(fDenSideN); + tOutputList->Add(fDenLongP); + tOutputList->Add(fDenLongN); + + return tOutputList; +} diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoCorrFctnNonIdDR.h b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoCorrFctnNonIdDR.h new file mode 100644 index 00000000000..45edb6672bd --- /dev/null +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoCorrFctnNonIdDR.h @@ -0,0 +1,54 @@ +//////////////////////////////////////////////////////////////////////////////// +// // +// AliFemtoCorrFctnNonIdDR - correlation function for non-identical particles // +// uses k* as a function variable. Stores the correlation function separately // +// for positive and negative signs of k* projections into out, side and long // +// directions, enabling the calculations of double ratios // +// // +//////////////////////////////////////////////////////////////////////////////// +#ifndef ALIFEMTOCORRFCTNNONIDDR_H +#define ALIFEMTOCORRFCTNNONIDDR_H + +#include "TH1D.h" +#include "AliFemtoCorrFctn.h" + +class AliFemtoCorrFctnNonIdDR : public AliFemtoCorrFctn { +public: + AliFemtoCorrFctnNonIdDR(char* title, const int& nbins, const float& QinvLo, const float& QinvHi); + AliFemtoCorrFctnNonIdDR(const AliFemtoCorrFctnNonIdDR& aCorrFctn); + virtual ~AliFemtoCorrFctnNonIdDR(); + + AliFemtoCorrFctnNonIdDR& operator=(const AliFemtoCorrFctnNonIdDR& aCorrFctn); + + virtual AliFemtoString Report(); + virtual void AddRealPair(AliFemtoPair* aPair); + virtual void AddMixedPair(AliFemtoPair* aPair); + + virtual void Finish(); + + virtual TList* GetOutputList(); + void Write(); + +private: + TH1D *fNumOutP; // Numerator for pair with positive k*out + TH1D *fNumOutN; // Numerator for pair with negative k*out + TH1D *fNumSideP; // Numerator for pair with positive k*side + TH1D *fNumSideN; // Numerator for pair with negative k*side + TH1D *fNumLongP; // Numerator for pair with positive k*long + TH1D *fNumLongN; // Numerator for pair with negative k*long + + TH1D *fDenOutP; // Denominator for pair with positive k*out + TH1D *fDenOutN; // Denominator for pair with negative k*out + TH1D *fDenSideP; // Denominator for pair with positive k*side + TH1D *fDenSideN; // Denominator for pair with negative k*side + TH1D *fDenLongP; // Denominator for pair with positive k*long + TH1D *fDenLongN; // Denominator for pair with negative k*long + +#ifdef __ROOT__ + ClassDef(AliFemtoCorrFctnNonIdDR, 1) +#endif +}; + + +#endif + diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoCutMonitor.h b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoCutMonitor.h index 7a20ef3aaa7..f9d622ecd04 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoCutMonitor.h +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoCutMonitor.h @@ -12,6 +12,7 @@ class AliFemtoKink; class AliFemtoPair; // Gael 12/04/02 #include "AliFemtoString.h" #include "AliFemtoParticleCollection.h" // Gael 19/06/02 +#include class AliFemtoCutMonitor{ @@ -27,7 +28,9 @@ public: } virtual void EventBegin(const AliFemtoEvent* aEvent) { /* no-op */ } virtual void EventEnd(const AliFemtoEvent* aEvent) { /* no-op */ } + virtual TList *GetOutputList() { TList *tOutputList = new TList(); return tOutputList; }; virtual void Fill(const AliFemtoEvent* aEvent) { + #ifdef STHBTDEBUG cout << " *** no user defined Fill(const AliFemtoEvent*), take from base class" << endl; #endif diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoCutMonitorHandler.cxx b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoCutMonitorHandler.cxx index 0d9ab9c70e2..c5af6eff427 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoCutMonitorHandler.cxx +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoCutMonitorHandler.cxx @@ -8,6 +8,7 @@ // // /////////////////////////////////////////////////////////////////////////// +#include #include "AliFemtoCutMonitorHandler.h" #include "AliFemtoTypes.h" @@ -246,7 +247,35 @@ AliFemtoCutMonitor* AliFemtoCutMonitorHandler::FailMonitor(int n) { iter++; return *iter; } +//_____________________________________________________________________________ +TList *AliFemtoCutMonitorHandler::GetOutputList() +{ + TList *tOutputList = new TList(); + + for (int ipass=0; ipasssize(); ipass++) { + TList *tLp = PassMonitor(ipass)->GetOutputList(); + + TIter nextLp(tLp); + while (TObject *obj = nextLp()) { + tOutputList->Add(obj); + } + + delete tLp; + } + for (int ipass=0; ipasssize(); ipass++) { + TList *tLf = FailMonitor(ipass)->GetOutputList(); + + TIter nextLf(tLf); + while (TObject *obj = nextLf()) { + tOutputList->Add(obj); + } + + delete tLf; + } + + return tOutputList; +} diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoCutMonitorHandler.h b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoCutMonitorHandler.h index 3012c81ab10..3596f28b914 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoCutMonitorHandler.h +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoCutMonitorHandler.h @@ -42,6 +42,8 @@ class AliFemtoCutMonitorHandler{ void FillCutMonitor(const AliFemtoParticleCollection* partColl);// Gael 19/06/02 void FillCutMonitor(const AliFemtoEvent* event, const AliFemtoParticleCollection* partColl);// Gael 19/06/02 void Finish(); + + virtual TList *GetOutputList(); private: bool fCollectionsEmpty; // Are the collections empty? diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoCutMonitorParticleYPt.cxx b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoCutMonitorParticleYPt.cxx new file mode 100644 index 00000000000..8ce73451efb --- /dev/null +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoCutMonitorParticleYPt.cxx @@ -0,0 +1,87 @@ +//////////////////////////////////////////////////////////////////////////////// +// // +// AliFemtoCutMonitorParticleYPt - the cut monitor for particles to study // +// the difference between reconstructed and true momentum // +// // +//////////////////////////////////////////////////////////////////////////////// +#include "AliFemtoCutMonitorParticleYPt.h" +#include "AliFemtoModelHiddenInfo.h" +#include +#include +#include + +AliFemtoCutMonitorParticleYPt::AliFemtoCutMonitorParticleYPt(): + fYPt(0), + fMass(0.13957) +{ + // Default constructor + fYPt = new TH2D("YPt", "Rapidity vs Pt", 100, -1.0, 1.0, 100, 0.1, 2.0); +} + +AliFemtoCutMonitorParticleYPt::AliFemtoCutMonitorParticleYPt(const char *aName, float aMass): + fYPt(0), + fMass(aMass) +{ + // Normal constructor + char name[200]; + snprintf(name, 200, "YPt%s", aName); + fYPt = new TH2D(name, "Rapdity vs Pt", 100, -1.0, 1.0, 100, 0.1, 2.0); +} + +AliFemtoCutMonitorParticleYPt::AliFemtoCutMonitorParticleYPt(const AliFemtoCutMonitorParticleYPt &aCut): + fYPt(0), + fMass(0.13957) +{ + // copy constructor + if (fYPt) delete fYPt; + fYPt = new TH2D(*aCut.fYPt); + fMass = aCut.fMass; +} + +AliFemtoCutMonitorParticleYPt::~AliFemtoCutMonitorParticleYPt() +{ + // Destructor + delete fYPt; +} + +AliFemtoCutMonitorParticleYPt& AliFemtoCutMonitorParticleYPt::operator=(const AliFemtoCutMonitorParticleYPt& aCut) +{ + // assignment operator + if (this == &aCut) + return *this; + + if (fYPt) delete fYPt; + fYPt = new TH2D(*aCut.fYPt); + + return *this; +} + +AliFemtoString AliFemtoCutMonitorParticleYPt::Report(){ + // Prepare report from the execution + string stemp = "*** AliFemtoCutMonitorParticleYPt report"; + AliFemtoString returnThis = stemp; + return returnThis; +} + +void AliFemtoCutMonitorParticleYPt::Fill(const AliFemtoTrack* aTrack) +{ + // Fill in the monitor histograms with the values from the current track + float tEnergy = ::sqrt(aTrack->P().mag2()+fMass*fMass); + float tRapidity = 0.5*::log((tEnergy+aTrack->P().z())/(tEnergy-aTrack->P().z())); + float tPt = ::sqrt((aTrack->P().x())*(aTrack->P().x())+(aTrack->P().y())*(aTrack->P().y())); + fYPt->Fill(tRapidity, tPt); +} + +void AliFemtoCutMonitorParticleYPt::Write() +{ + // Write out the relevant histograms + fYPt->Write(); +} + +TList *AliFemtoCutMonitorParticleYPt::GetOutputList() +{ + TList *tOutputList = new TList(); + tOutputList->Add(fYPt); + + return tOutputList; +} diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoCutMonitorParticleYPt.h b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoCutMonitorParticleYPt.h new file mode 100644 index 00000000000..4ba4f5bb2b2 --- /dev/null +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoCutMonitorParticleYPt.h @@ -0,0 +1,43 @@ +//////////////////////////////////////////////////////////////////////////////// +/// /// +/// AliFemtoCutMonitorParticleYPt - the cut monitor for particles to study /// +/// the difference between reconstructed and true momentum /// +/// /// +//////////////////////////////////////////////////////////////////////////////// +#ifndef AliFemtoCutMonitorParticleYPt_hh +#define AliFemtoCutMonitorParticleYPt_hh + +class AliFemtoEvent; +class AliFemtoTrack; +class AliFemtoV0; +class AliFemtoKink; +class AliFemtoPair; // Gael 12/04/02 +class TH1D; +class TH2D; +class TList; +#include "AliFemtoString.h" +#include "AliFemtoParticleCollection.h" +#include "AliFemtoCutMonitor.h" + +class AliFemtoCutMonitorParticleYPt : public AliFemtoCutMonitor{ + +public: + AliFemtoCutMonitorParticleYPt(); + AliFemtoCutMonitorParticleYPt(const char *aName, float aMass); + AliFemtoCutMonitorParticleYPt(const AliFemtoCutMonitorParticleYPt &aCut); + virtual ~AliFemtoCutMonitorParticleYPt(); + + AliFemtoCutMonitorParticleYPt& operator=(const AliFemtoCutMonitorParticleYPt& aCut); + + virtual AliFemtoString Report(); + virtual void Fill(const AliFemtoTrack* aTrack); + void Write(); + + virtual TList *GetOutputList(); + +private: + TH2D *fYPt; // Rapidity vs. Pt monitor + float fMass; // Mass hypothesis +}; + +#endif diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoDummyPairCut.cxx b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoDummyPairCut.cxx index 50d353c1cac..b131bbf23b3 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoDummyPairCut.cxx +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoDummyPairCut.cxx @@ -1,3 +1,8 @@ +/////////////////////////////////////////////////////////////////////////// +// // +// AliFemtoDummyPairCut: a summy pair cut. Accepts all pairs // +// // +/////////////////////////////////////////////////////////////////////////// /*************************************************************************** * * $Id$ @@ -65,9 +70,9 @@ AliFemtoDummyPairCut::AliFemtoDummyPairCut() : /* no-op */ } //__________________ -//AliFemtoDummyPairCut::~AliFemtoDummyPairCut(){ -// /* no-op */ -//} +AliFemtoDummyPairCut::~AliFemtoDummyPairCut(){ + /* no-op */ +} //__________________ bool AliFemtoDummyPairCut::Pass(const AliFemtoPair* pair){ // Pass all pairs diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoDummyPairCut.h b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoDummyPairCut.h index 258d6837362..3c2bb9f1e39 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoDummyPairCut.h +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoDummyPairCut.h @@ -1,3 +1,8 @@ +/////////////////////////////////////////////////////////////////////////// +// // +// AliFemtoDummyPairCut: a summy pair cut. Accepts all pairs // +// // +/////////////////////////////////////////////////////////////////////////// /*************************************************************************** * * $Id$ @@ -84,7 +89,7 @@ class AliFemtoDummyPairCut : public AliFemtoPairCut{ public: AliFemtoDummyPairCut(); AliFemtoDummyPairCut(const AliFemtoDummyPairCut&); - //~AliFemtoDummyPairCut(); + virtual ~AliFemtoDummyPairCut(); virtual bool Pass(const AliFemtoPair*); virtual AliFemtoString Report(); diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoEventReaderESD.cxx b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoEventReaderESD.cxx index 88235bcc2fa..b1d0a46073a 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoEventReaderESD.cxx +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoEventReaderESD.cxx @@ -353,6 +353,18 @@ AliFemtoEvent* AliFemtoEventReaderESD::ReturnHbtEvent() trackCopy->SetTPCClusterMap(esdtrack->GetTPCClusterMap()); trackCopy->SetTPCSharedMap(esdtrack->GetTPCSharedMap()); + double pvrt[3]; + fEvent->GetPrimaryVertex()->GetXYZ(pvrt); + + double xtpc[3]; + esdtrack->GetInnerXYZ(xtpc); + xtpc[2] -= pvrt[2]; + trackCopy->SetNominalTPCEntrancePoint(xtpc); + + esdtrack->GetOuterXYZ(xtpc); + xtpc[2] -= pvrt[2]; + trackCopy->SetNominalTPCExitPoint(xtpc); + int indexes[3]; for (int ik=0; ik<3; ik++) { indexes[ik] = esdtrack->GetKinkIndex(ik); diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoEventReaderESDChain.cxx b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoEventReaderESDChain.cxx index fd60fb2ec1d..f9a275abde0 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoEventReaderESDChain.cxx +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoEventReaderESDChain.cxx @@ -269,7 +269,7 @@ AliFemtoEvent* AliFemtoEventReaderESDChain::ReturnHbtEvent() tGoodMomentum=esdtrack->GetPxPyPz(pxyz);//reading noconstarined momentum AliFemtoThreeVector v(pxyz[0],pxyz[1],pxyz[2]); - if (v.mag() == 0) { + if (v.mag() < 0.0001) { // cout << "Found 0 momentum ???? " <SetTPCnclsF(esdtrack->GetTPCNclsF()); trackCopy->SetTPCsignalN((short)esdtrack->GetTPCsignalN()); //due to bug in aliesdtrack class trackCopy->SetTPCsignalS(esdtrack->GetTPCsignalSigma()); - -// // Fill cluster per padrow information -// Int_t tTrackIndices[AliESDfriendTrack::kMaxTPCcluster]; -// Int_t tNClusters = esdtrack->GetTPCclusters(tTrackIndices); -// for (int tNcl=0; tNcl 0) -// trackCopy->SetTPCcluster(tNcl, 1); -// else -// trackCopy->SetTPCcluster(tNcl, 0); -// } - -// // Fill shared cluster information -// list::iterator tClustIter; - -// for (int tNcl=0; tNcl 0) { -// tClustIter = find(fSharedList[tNcl]->begin(), fSharedList[tNcl]->end(), tTrackIndices[tNcl]); -// if (tClustIter != fSharedList[tNcl]->end()) { -// trackCopy->SetTPCshared(tNcl, 1); -// cout << "Event next" << endl; -// cout << "Track: " << i << endl; -// cout << "Shared cluster: " << tNcl << " " << tTrackIndices[tNcl] << endl; -// } -// else { -// trackCopy->SetTPCshared(tNcl, 0); -// } -// } -// } + trackCopy->SetSigmaToVertex(GetSigmaToVertex(esdtrack)); trackCopy->SetTPCClusterMap(esdtrack->GetTPCClusterMap()); trackCopy->SetTPCSharedMap(esdtrack->GetTPCSharedMap()); + double pvrt[3]; + fEvent->GetPrimaryVertex()->GetXYZ(pvrt); + + double xtpc[3]; + esdtrack->GetInnerXYZ(xtpc); + xtpc[2] -= pvrt[2]; + trackCopy->SetNominalTPCEntrancePoint(xtpc); + + esdtrack->GetOuterXYZ(xtpc); + xtpc[2] -= pvrt[2]; + trackCopy->SetNominalTPCExitPoint(xtpc); + + int indexes[3]; + for (int ik=0; ik<3; ik++) { + indexes[ik] = esdtrack->GetKinkIndex(ik); + } + trackCopy->SetKinkIndexes(indexes); + //decision if we want this track + //if we using diffrent labels we want that this label was use for first time + //if we use hidden info we want to have match between sim data and ESD if (tGoodMomentum==true) { hbtEvent->TrackCollection()->push_back(trackCopy);//adding track to analysis @@ -367,6 +360,46 @@ void AliFemtoEventReaderESDChain::SetESDSource(AliESDEvent *aESD) // fEventFriend = aFriend; // } +//____________________________________________________________________ +Float_t AliFemtoEventReaderESDChain::GetSigmaToVertex(const AliESDtrack* esdTrack) +{ + // Calculates the number of sigma to the vertex. + + Float_t b[2]; + Float_t bRes[2]; + Float_t bCov[3]; + esdTrack->GetImpactParameters(b,bCov); +// if (bCov[0]<=0 || bCov[2]<=0) { +// AliDebug(1, "Estimated b resolution lower or equal zero!"); +// bCov[0]=0; bCov[2]=0; +// } + bRes[0] = TMath::Sqrt(bCov[0]); + bRes[1] = TMath::Sqrt(bCov[2]); + + // ----------------------------------- + // How to get to a n-sigma cut? + // + // The accumulated statistics from 0 to d is + // + // -> Erf(d/Sqrt(2)) for a 1-dim gauss (d = n_sigma) + // -> 1 - Exp(-d**2) for a 2-dim gauss (d*d = dx*dx + dy*dy != n_sigma) + // + // It means that for a 2-dim gauss: n_sigma(d) = Sqrt(2)*ErfInv(1 - Exp((-x**2)/2) + // Can this be expressed in a different way? + + if (bRes[0] == 0 || bRes[1] ==0) + return -1; + + Float_t d = TMath::Sqrt(TMath::Power(b[0]/bRes[0],2) + TMath::Power(b[1]/bRes[1],2)); + + // stupid rounding problem screws up everything: + // if d is too big, TMath::Exp(...) gets 0, and TMath::ErfInverse(1) that should be infinite, gets 0 :( + if (TMath::Exp(-d * d / 2) < 1e-10) + return 1000; + + d = TMath::ErfInverse(1 - TMath::Exp(-d * d / 2)) * TMath::Sqrt(2); + return d; +} diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoEventReaderESDChain.h b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoEventReaderESDChain.h index ac4368fec8f..792706b315b 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoEventReaderESDChain.h +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoEventReaderESDChain.h @@ -52,6 +52,8 @@ class AliFemtoEventReaderESDChain : public AliFemtoEventReader /* list **fSharedList; //! Table (one list per padrow) of clusters which are shared */ /* list **fClusterPerPadrow; //! Table (one list per padrow) of clusters in each padrow */ + Float_t GetSigmaToVertex(const AliESDtrack* esdTrack); + #ifdef __ROOT__ ClassDef(AliFemtoEventReaderESDChain, 1) #endif diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoEventReaderESDChainKine.cxx b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoEventReaderESDChainKine.cxx new file mode 100644 index 00000000000..042c0c62e53 --- /dev/null +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoEventReaderESDChainKine.cxx @@ -0,0 +1,296 @@ +//////////////////////////////////////////////////////////////////////////////// +// // +// AliFemtoEventReaderESDChainKine - the reader class for the Alice ESD and // +// the model Kinematics information tailored for the Task framework and the // +// Reads in AliESDfriend to create shared hit/quality information // +// Authors: Adam Kisiel kisiel@mps.ohio-state.edu // +// // +//////////////////////////////////////////////////////////////////////////////// +#include "AliFemtoEventReaderESDChainKine.h" + +#include "TFile.h" +#include "TTree.h" +#include "AliESDEvent.h" +#include "AliESDtrack.h" +#include "AliESDVertex.h" + +#include "AliFmPhysicalHelixD.h" +#include "AliFmThreeVectorF.h" + +#include "SystemOfUnits.h" + +#include "AliFemtoEvent.h" + +#include "AliAODParticle.h" +#include "TParticle.h" +#include "AliFemtoModelHiddenInfo.h" + +ClassImp(AliFemtoEventReaderESDChainKine) + +#if !(ST_NO_NAMESPACES) + using namespace units; +#endif + +using namespace std; +//____________________________ +AliFemtoEventReaderESDChainKine::AliFemtoEventReaderESDChainKine(): + fFileName(" "), + fConstrained(true), + fNumberofEvent(0), + fCurEvent(0), + fCurFile(0), + fEvent(0x0), + fStack(0x0) +{ + //constructor with 0 parameters , look at default settings +} + +//__________________ +AliFemtoEventReaderESDChainKine::AliFemtoEventReaderESDChainKine(const AliFemtoEventReaderESDChainKine& aReader): + fFileName(" "), + fConstrained(true), + fNumberofEvent(0), + fCurEvent(0), + fCurFile(0), + fEvent(0x0), + fStack(0x0) +{ + // Copy constructor + fConstrained = aReader.fConstrained; + fNumberofEvent = aReader.fNumberofEvent; + fCurEvent = aReader.fCurEvent; + fCurFile = aReader.fCurFile; + fEvent = new AliESDEvent(); + fStack = aReader.fStack; +} +//__________________ +AliFemtoEventReaderESDChainKine::~AliFemtoEventReaderESDChainKine() +{ + //Destructor + delete fEvent; +} + +//__________________ +AliFemtoEventReaderESDChainKine& AliFemtoEventReaderESDChainKine::operator=(const AliFemtoEventReaderESDChainKine& aReader) +{ + // Assignment operator + if (this == &aReader) + return *this; + + fConstrained = aReader.fConstrained; + fNumberofEvent = aReader.fNumberofEvent; + fCurEvent = aReader.fCurEvent; + fCurFile = aReader.fCurFile; + if (fEvent) delete fEvent; + fEvent = new AliESDEvent(); + fStack = aReader.fStack; + + return *this; +} +//__________________ +// Simple report +AliFemtoString AliFemtoEventReaderESDChainKine::Report() +{ + AliFemtoString temp = "\n This is the AliFemtoEventReaderESDChainKine\n"; + return temp; +} + +//__________________ +void AliFemtoEventReaderESDChainKine::SetConstrained(const bool constrained) +{ + // Select whether to read constrained or not constrained momentum + fConstrained=constrained; +} +//__________________ +bool AliFemtoEventReaderESDChainKine::GetConstrained() const +{ + // Check whether we read constrained or not constrained momentum + return fConstrained; +} +//__________________ +AliFemtoEvent* AliFemtoEventReaderESDChainKine::ReturnHbtEvent() +{ + // Get the event, read all the relevant information + // and fill the AliFemtoEvent class + // Returns a valid AliFemtoEvent + AliFemtoEvent *hbtEvent = 0; + string tFriendFileName; + + // Get the friend information + cout<<"starting to read event "<SetESDfriend(fEventFriend); + + hbtEvent = new AliFemtoEvent; + //setting basic things + // hbtEvent->SetEventNumber(fEvent->GetEventNumber()); + hbtEvent->SetRunNumber(fEvent->GetRunNumber()); + //hbtEvent->SetNumberOfTracks(fEvent->GetNumberOfTracks()); + hbtEvent->SetMagneticField(fEvent->GetMagneticField()*kilogauss);//to check if here is ok + hbtEvent->SetZDCN1Energy(fEvent->GetZDCN1Energy()); + hbtEvent->SetZDCP1Energy(fEvent->GetZDCP1Energy()); + hbtEvent->SetZDCN2Energy(fEvent->GetZDCN2Energy()); + hbtEvent->SetZDCP2Energy(fEvent->GetZDCP2Energy()); + hbtEvent->SetZDCEMEnergy(fEvent->GetZDCEMEnergy()); + hbtEvent->SetZDCParticipants(fEvent->GetZDCParticipants()); + hbtEvent->SetTriggerMask(fEvent->GetTriggerMask()); + hbtEvent->SetTriggerCluster(fEvent->GetTriggerCluster()); + + //Vertex + double fV1[3]; + fEvent->GetVertex()->GetXYZ(fV1); + + AliFmThreeVectorF vertex(fV1[0],fV1[1],fV1[2]); + hbtEvent->SetPrimVertPos(vertex); + + //starting to reading tracks + int nofTracks=0; //number of reconstructed tracks in event + nofTracks=fEvent->GetNumberOfTracks(); + int realnofTracks=0;//number of track which we use ina analysis + + for (int i=0;iGetTrack(i);//getting next track + // const AliESDfriendTrack *tESDfriendTrack = esdtrack->GetFriendTrack(); + + trackCopy->SetCharge((short)esdtrack->GetSign()); + + //in aliroot we have AliPID + //0-electron 1-muon 2-pion 3-kaon 4-proton 5-photon 6-pi0 7-neutron 8-kaon0 9-eleCon + //we use only 5 first + double esdpid[5]; + esdtrack->GetESDpid(esdpid); + trackCopy->SetPidProbElectron(esdpid[0]); + trackCopy->SetPidProbMuon(esdpid[1]); + trackCopy->SetPidProbPion(esdpid[2]); + trackCopy->SetPidProbKaon(esdpid[3]); + trackCopy->SetPidProbProton(esdpid[4]); + + double pxyz[3]; + if (fConstrained==true) + tGoodMomentum=esdtrack->GetConstrainedPxPyPz(pxyz); //reading constrained momentum + else + tGoodMomentum=esdtrack->GetPxPyPz(pxyz);//reading noconstarined momentum + + AliFemtoThreeVector v(pxyz[0],pxyz[1],pxyz[2]); + if (v.mag() < 0.0001) { + // cout << "Found 0 momentum ???? " <SetP(v);//setting momentum + trackCopy->SetPt(sqrt(pxyz[0]*pxyz[0]+pxyz[1]*pxyz[1])); + const AliFmThreeVectorD kP(pxyz[0],pxyz[1],pxyz[2]); + const AliFmThreeVectorD kOrigin(fV1[0],fV1[1],fV1[2]); + //setting helix I do not if it is ok + AliFmPhysicalHelixD helix(kP,kOrigin,(double)(fEvent->GetMagneticField())*kilogauss,(double)(trackCopy->Charge())); + trackCopy->SetHelix(helix); + + trackCopy->SetTrackId(esdtrack->GetID()); + trackCopy->SetFlags(esdtrack->GetStatus()); + trackCopy->SetLabel(esdtrack->GetLabel()); + + //some stuff which could be useful + float impact[2]; + float covimpact[3]; + esdtrack->GetImpactParameters(impact,covimpact); + trackCopy->SetImpactD(impact[0]); + trackCopy->SetImpactZ(impact[1]); + trackCopy->SetCdd(covimpact[0]); + trackCopy->SetCdz(covimpact[1]); + trackCopy->SetCzz(covimpact[2]); + trackCopy->SetITSchi2(esdtrack->GetITSchi2()); + trackCopy->SetITSncls(esdtrack->GetNcls(0)); + trackCopy->SetTPCchi2(esdtrack->GetTPCchi2()); + trackCopy->SetTPCncls(esdtrack->GetTPCNcls()); + trackCopy->SetTPCnclsF(esdtrack->GetTPCNclsF()); + trackCopy->SetTPCsignalN((short)esdtrack->GetTPCsignalN()); //due to bug in aliesdtrack class + trackCopy->SetTPCsignalS(esdtrack->GetTPCsignalSigma()); + + + trackCopy->SetTPCClusterMap(esdtrack->GetTPCClusterMap()); + trackCopy->SetTPCSharedMap(esdtrack->GetTPCSharedMap()); + + double pvrt[3]; + fEvent->GetPrimaryVertex()->GetXYZ(pvrt); + + double xtpc[3]; + esdtrack->GetInnerXYZ(xtpc); + xtpc[2] -= pvrt[2]; + trackCopy->SetNominalTPCEntrancePoint(xtpc); + + esdtrack->GetOuterXYZ(xtpc); + xtpc[2] -= pvrt[2]; + trackCopy->SetNominalTPCExitPoint(xtpc); + + int indexes[3]; + for (int ik=0; ik<3; ik++) { + indexes[ik] = esdtrack->GetKinkIndex(ik); + } + trackCopy->SetKinkIndexes(indexes); + + // Fill the hidden information with the simulated data + TParticle *tPart = fStack->Particle(TMath::Abs(esdtrack->GetLabel())); + AliAODParticle* tParticle= new AliAODParticle(*tPart,i); + AliFemtoModelHiddenInfo *tInfo = new AliFemtoModelHiddenInfo(); + tInfo->SetPDGPid(tParticle->GetMostProbable()); + tInfo->SetTrueMomentum(tParticle->Px(), tParticle->Py(), tParticle->Pz()); + Double_t mass2 = (tParticle->E()*tParticle->E() - + tParticle->Px()*tParticle->Px() - + tParticle->Py()*tParticle->Py() - + tParticle->Pz()*tParticle->Pz()); + + + if (mass2>0.0) + tInfo->SetMass(TMath::Sqrt(mass2)); + else + tInfo->SetMass(0.0); + tInfo->SetEmissionPoint(tParticle->Vx(), tParticle->Vy(), tParticle->Vz(), tParticle->T()); + trackCopy->SetHiddenInfo(tInfo); + + //decision if we want this track + //if we using diffrent labels we want that this label was use for first time + //if we use hidden info we want to have match between sim data and ESD + if (tGoodMomentum==true) + { + hbtEvent->TrackCollection()->push_back(trackCopy);//adding track to analysis + realnofTracks++;//real number of tracks + // delete trackCopy; + } + else + { + delete trackCopy; + } + + } + + hbtEvent->SetNumberOfTracks(realnofTracks);//setting number of track which we read in event + fCurEvent++; + cout<<"end of reading nt "< +#include +#include +#include +#include +#include +#include + +class AliFemtoEvent; + +class AliFemtoEventReaderESDChainKine : public AliFemtoEventReader +{ + public: + AliFemtoEventReaderESDChainKine(); + AliFemtoEventReaderESDChainKine(const AliFemtoEventReaderESDChainKine& aReader); + ~AliFemtoEventReaderESDChainKine(); + + AliFemtoEventReaderESDChainKine& operator=(const AliFemtoEventReaderESDChainKine& aReader); + + AliFemtoEvent* ReturnHbtEvent(); + AliFemtoString Report(); + void SetConstrained(const bool constrained); + bool GetConstrained() const; + + void SetESDSource(AliESDEvent *aESD); + void SetStackSource(AliStack *aStack); + + protected: + + private: + string fFileName; // name of current ESD file + bool fConstrained; // flag to set which momentum from ESD file will be use + int fNumberofEvent; // number of Events in ESD file + int fCurEvent; // number of current event + unsigned int fCurFile; // number of current file + AliESDEvent* fEvent; // ESD event + AliStack *fStack; // Kinematics stack pointer + +#ifdef __ROOT__ + ClassDef(AliFemtoEventReaderESDChainKine, 1) +#endif + + }; + +#endif + + diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoKTPairCut.cxx b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoKTPairCut.cxx new file mode 100644 index 00000000000..8581c6ccca5 --- /dev/null +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoKTPairCut.cxx @@ -0,0 +1,99 @@ +///////////////////////////////////////////////////////////////////////////// +// // +// AliFemtoKTPairCut - a pair cut which selects pairs based on their // +// transverse momentum kT // +// // +///////////////////////////////////////////////////////////////////////////// +/*************************************************************************** + * + * $Id: AliFemtoKTPairCut.cxx,v 1.1.2.2 2007/11/09 11:20:35 akisiel Exp $ + * + * Author: Adam Kisiel, Ohio State, kisiel@mps.ohio-state.edu + *************************************************************************** + * + * Description: part of STAR HBT Framework: AliFemtoMaker package + * a cut to remove "shared" and "split" pairs + * + *************************************************************************** + * + * + **************************************************************************/ + +#include "AliFemtoKTPairCut.h" +#include +#include + +#ifdef __ROOT__ +ClassImp(AliFemtoKTPairCut) +#endif + +//__________________ +AliFemtoKTPairCut::AliFemtoKTPairCut(): + AliFemtoPairCut(), + fKTMin(0), + fKTMax(1.0e6) +{ + fKTMin = 0; + fKTMax = 1.0e6; +} +//__________________ +AliFemtoKTPairCut::AliFemtoKTPairCut(double lo, double hi) : + AliFemtoPairCut(), + fKTMin(lo), + fKTMax(hi) +{ +} +//__________________ +AliFemtoKTPairCut::AliFemtoKTPairCut(const AliFemtoKTPairCut& c) : + AliFemtoPairCut(c), + fKTMin(0), + fKTMax(1.0e6) +{ + fKTMin = c.fKTMin; + fKTMax = c.fKTMax; +} + +//__________________ +AliFemtoKTPairCut::~AliFemtoKTPairCut(){ + /* no-op */ +} +//__________________ +bool AliFemtoKTPairCut::Pass(const AliFemtoPair* pair){ + bool temp = true; + + if (pair->KT() < fKTMin) + temp = false; + + if (pair->KT() > fKTMax) + temp = false; + + return temp; +} +//__________________ +AliFemtoString AliFemtoKTPairCut::Report(){ + // Prepare a report from the execution + string stemp = "AliFemtoKT Pair Cut \n"; char ctemp[100]; + sprintf(ctemp,"Accept pair with kT in range %lf , %lf",fKTMin,fKTMax); + stemp += ctemp; + AliFemtoString returnThis = stemp; + return returnThis;} +//__________________ + +TList *AliFemtoKTPairCut::ListSettings() +{ + // return a list of settings in a writable form + TList *tListSetttings = new TList(); + char buf[200]; + snprintf(buf, 200, "AliFemtoKTPairCut.ktmax=%lf", fKTMax); + tListSetttings->AddLast(new TObjString(buf)); + snprintf(buf, 200, "AliFemtoKTPairCut.ktmin=%lf", fKTMin); + tListSetttings->AddLast(new TObjString(buf)); + + return tListSetttings; +} + +void AliFemtoKTPairCut::SetKTRange(double ktmin, double ktmax) +{ + fKTMin = ktmin; + fKTMax = ktmax; +} diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoKTPairCut.h b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoKTPairCut.h new file mode 100644 index 00000000000..affb8d696b5 --- /dev/null +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoKTPairCut.h @@ -0,0 +1,57 @@ +///////////////////////////////////////////////////////////////////////////// +// // +// AliFemtoKTPairCut - a pair cut which selects pairs based on their // +// transverse momentum kT // +// // +///////////////////////////////////////////////////////////////////////////// +/*************************************************************************** + * + * $Id: AliFemtoKTPairCut.h,v 1.1.2.1 2007/10/19 13:28:14 akisiel Exp $ + * + * Author: Adam Kisiel, Ohio State University, kisiel@mps.ohio-state.edu + *************************************************************************** + * + * Description: part of STAR HBT Framework: AliFemtoMaker package + * a cut to remove "shared" and "split" pairs + * + *************************************************************************** + * + * + **************************************************************************/ + + +#ifndef ALIFEMTOKTPAIRCUT_H +#define ALIFEMTOKTPAIRCUT_H + +// do I need these lines ? +//#ifndef StMaker_H +//#include "StMaker.h" +//#endif + +#include "AliFemtoPairCut.h" + +class AliFemtoKTPairCut : public AliFemtoPairCut{ +public: + AliFemtoKTPairCut(); + AliFemtoKTPairCut(double lo, double hi); + AliFemtoKTPairCut(const AliFemtoKTPairCut& c); + virtual ~AliFemtoKTPairCut(); + + virtual bool Pass(const AliFemtoPair* pair); + virtual AliFemtoString Report(); + virtual TList *ListSettings(); + AliFemtoPairCut* Clone(); + void SetKTRange(double ktmin, double ktmax); + + protected: + Double_t fKTMin; // Minimum allowed pair transverse momentum + Double_t fKTMax; // Maximum allowed pair transverse momentum + +#ifdef __ROOT__ + ClassDef(AliFemtoKTPairCut, 0) +#endif +}; + +inline AliFemtoPairCut* AliFemtoKTPairCut::Clone() { AliFemtoKTPairCut* c = new AliFemtoKTPairCut(*this); return c;} + +#endif diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoKink.cxx b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoKink.cxx index 7c87a57e15c..9f325abe70c 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoKink.cxx +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoKink.cxx @@ -1,3 +1,12 @@ +/////////////////////////////////////////////////////////////////////////// +// // +// AliFemtoKink: main class holding all the necessary information // +// about a kink (before the identification) that is required during // +// femtoscopic analysis. This class is filled with information from the // +// input stream by the reader. A particle has a link back to the Kink // +// it was created from, so we do not copy the information. // +// // +/////////////////////////////////////////////////////////////////////////// /*********************************************************************** * * $Id$ @@ -61,8 +70,8 @@ AliFemtoKink::AliFemtoKink(): fHitDistanceParentVertex(0), fDecayAngle(0), fDecayAngleCM(0), fDaughter(), - mParent(), - mPosition(0,0,0) + fParent(), + fPosition(0,0,0) {/* no-op */} // ----------------------------------------------------------------------- AliFemtoKink::AliFemtoKink(const AliFemtoKink& k): @@ -71,8 +80,8 @@ AliFemtoKink::AliFemtoKink(const AliFemtoKink& k): fHitDistanceParentVertex(0), fDecayAngle(0), fDecayAngleCM(0), fDaughter(), - mParent(), - mPosition(0,0,0) + fParent(), + fPosition(0,0,0) { // copy constructor fDcaParentDaughter = k.fDcaParentDaughter; @@ -86,8 +95,8 @@ AliFemtoKink::AliFemtoKink(const AliFemtoKink& k): fDecayAngle = k.fDecayAngle; fDecayAngleCM = k.fDecayAngleCM; fDaughter = k.fDaughter; - mParent = k.mParent; - mPosition = k.mPosition; + fParent = k.fParent; + fPosition = k.fPosition; } // ----------------------------------------------------------------------- @@ -123,13 +132,13 @@ AliFemtoKink::AliFemtoKink( const StKinkVertex& SKV, AliFemtoThreeVector Primary // Parent StTrk = SKV.parent(); HbtTrk = new AliFemtoTrack(StTrk,PrimaryVertex); // generate NEW HbtTrack from StTrack - mParent = *HbtTrk; // invoke copy ctr of AliFemtoTrack + fParent = *HbtTrk; // invoke copy ctr of AliFemtoTrack delete HbtTrk; // get rid of the NEW HbtTrack - we are done with that // finally, the kink position - mPosition.setX(SKV.position().x()); - mPosition.setY(SKV.position().y()); - mPosition.setZ(SKV.position().z()); + fPosition.setX(SKV.position().x()); + fPosition.setY(SKV.position().y()); + fPosition.setZ(SKV.position().z()); } diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoKink.h b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoKink.h index 64d5cd52d4f..cad73d4e22f 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoKink.h +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoKink.h @@ -1,3 +1,12 @@ +/////////////////////////////////////////////////////////////////////////// +// // +// AliFemtoKink: main class holding all the necessary information // +// about a kink (before the identification) that is required during // +// femtoscopic analysis. This class is filled with information from the // +// input stream by the reader. A particle has a link back to the Kink // +// it was created from, so we do not copy the information. // +// // +/////////////////////////////////////////////////////////////////////////// /*********************************************************************** * * $Id$ @@ -47,8 +56,8 @@ * * ***********************************************************************/ -#ifndef AliFemtoKink_hh -#define AliFemtoKink_hh +#ifndef ALIFEMTOKINK_H +#define ALIFEMTOKINK_H class StKinkVertex; //#include "StEvent/StKinkVertex.h" // from StEvent @@ -59,7 +68,7 @@ class StKinkVertex; class AliFemtoKink { public: AliFemtoKink(); - AliFemtoKink( const AliFemtoKink&); // copy constructor + AliFemtoKink( const AliFemtoKink& k); // copy constructor #ifndef __NO_STAR_DEPENDENCE_ALLOWED__ #ifdef __ROOT__ AliFemtoKink( const StKinkVertex&, AliFemtoThreeVector PrimaryVertex); // create a AliFemtoKink from a StKinkVertex @@ -93,8 +102,8 @@ protected: float fDecayAngle; // from StKinkVertex class directly float fDecayAngleCM; // from StKinkVertex class directly AliFemtoTrack fDaughter; // from StKinkVertex class directly - AliFemtoTrack mParent; // from StVertex class (which StKinkVertex inherits from) - AliFemtoThreeVector mPosition; // from StMeasuredPoint class (which StVertex inherits from) + AliFemtoTrack fParent; // from StVertex class (which StKinkVertex inherits from) + AliFemtoThreeVector fPosition; // from StMeasuredPoint class (which StVertex inherits from) }; @@ -108,8 +117,8 @@ inline float AliFemtoKink::DeltaEnergy(int i) const {return fDeltaEnergy[ inline float AliFemtoKink::DecayAngle() const {return fDecayAngle;} inline float AliFemtoKink::DecayAngleCM() const {return fDecayAngleCM;} inline AliFemtoTrack AliFemtoKink::Daughter() const {return fDaughter;} -inline AliFemtoTrack AliFemtoKink::Parent() const {return mParent;} -inline AliFemtoThreeVector AliFemtoKink::Position() const {return mPosition;} +inline AliFemtoTrack AliFemtoKink::Parent() const {return fParent;} +inline AliFemtoThreeVector AliFemtoKink::Position() const {return fPosition;} diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoLikeSignCorrFctn.h b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoLikeSignCorrFctn.h index 4fd9e6d8c16..26bdb890939 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoLikeSignCorrFctn.h +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoLikeSignCorrFctn.h @@ -22,6 +22,7 @@ public: virtual void AddLikeSignNegativePair(const AliFemtoPair* aPair) = 0; virtual AliFemtoLikeSignCorrFctn* Clone() { return 0;} + virtual TList* GetOutputList() = 0; // the following allows "back-pointing" from the CorrFctn to the "parent" Analysis }; diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoManager.h b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoManager.h index 6272421412f..df4edcce16a 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoManager.h +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoManager.h @@ -46,7 +46,6 @@ public: AliFemtoEventReader* EventReader(); void SetEventReader(AliFemtoEventReader* r); - int Init(); int ProcessEvent(); // a "0" return value means success - otherwise quit void Finish(); diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelCorrFctn.cxx b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelCorrFctn.cxx index c73dc1f89d0..69f745fef47 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelCorrFctn.cxx +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelCorrFctn.cxx @@ -157,4 +157,15 @@ AliFemtoModelCorrFctn* AliFemtoModelCorrFctn::Clone() return tCopy; } +//_________________________ +TList* AliFemtoModelCorrFctn::GetOutputList() +{ + // Prepare the list of objects to be written to the output + TList *tOutputList = new TList(); + + tOutputList->Add(fNumeratorTrue); + tOutputList->Add(fNumeratorFake); + tOutputList->Add(fDenominator); + return tOutputList; +} diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelCorrFctn.h b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelCorrFctn.h index 74eaa776ebe..43a256fb645 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelCorrFctn.h +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelCorrFctn.h @@ -33,6 +33,7 @@ public: virtual void EventEnd(const AliFemtoEvent* aEvent); virtual void Finish(); + virtual TList* GetOutputList(); virtual void Write(); virtual AliFemtoModelCorrFctn* Clone(); @@ -41,7 +42,7 @@ public: void SetAnalysis(AliFemtoAnalysis* aAnalysis); protected: - AliFemtoModelManager *fManager; // Link back to the managet to get the weights + AliFemtoModelManager *fManager; // Link back to the manager to get the weights TH1D *fNumeratorTrue; // Numerator made with pairs from the same event TH1D *fNumeratorFake; // Numerator made with pairs from different events (mixed pairs) diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelHiddenInfo.cxx b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelHiddenInfo.cxx index 98662cc48d4..1a4a5cdc166 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelHiddenInfo.cxx +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelHiddenInfo.cxx @@ -155,10 +155,15 @@ void AliFemtoModelHiddenInfo::SetMass(Double_t aMass) void AliFemtoModelHiddenInfo::SetEmissionPoint(Double_t aRx, Double_t aRy, Double_t aRz, Double_t aT) { // set position from components - fEmissionPoint->setX(aRx); - fEmissionPoint->setY(aRy); - fEmissionPoint->setZ(aRz); - fEmissionPoint->setT(aT); + if (fEmissionPoint) { + fEmissionPoint->setX(aRx); + fEmissionPoint->setY(aRy); + fEmissionPoint->setZ(aRz); + fEmissionPoint->setT(aT); + } + else { + fEmissionPoint = new AliFemtoLorentzVector(aRx, aRy, aRz, aT); + } } //_____________________________________________ AliFemtoHiddenInfo* AliFemtoModelHiddenInfo::GetParticleHiddenInfo() const diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelWeightGenerator.cxx b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelWeightGenerator.cxx index e1f767497cd..09d63f04bfd 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelWeightGenerator.cxx +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelWeightGenerator.cxx @@ -14,6 +14,7 @@ #include "AliFemtoModelWeightGenerator.h" #include "AliFemtoModelHiddenInfo.h" +const Int_t AliFemtoModelWeightGenerator::fgkPairTypeNone = 0; const Int_t AliFemtoModelWeightGenerator::fgkPionPlusPionPlus = 1; const Int_t AliFemtoModelWeightGenerator::fgkPionPlusPionMinus = 2; const Int_t AliFemtoModelWeightGenerator::fgkKaonPlusKaonPlus = 3; @@ -57,50 +58,59 @@ Int_t AliFemtoModelWeightGenerator::GetPairType() const //_____________________________________________ void AliFemtoModelWeightGenerator::SetPairTypeFromPair(AliFemtoPair *aPair) +{ + fPairType = GetPairTypeFromPair(aPair); +} +//_____________________________________________ +Int_t AliFemtoModelWeightGenerator::GetPairTypeFromPair(AliFemtoPair *aPair) { // Get the type of pair from PID of particles in the pair AliFemtoModelHiddenInfo *inf1 = ( AliFemtoModelHiddenInfo *) aPair->Track1()->HiddenInfo(); AliFemtoModelHiddenInfo *inf2 = ( AliFemtoModelHiddenInfo *) aPair->Track2()->HiddenInfo(); + Int_t tPairType = fgkPairTypeNone; + const Int_t ktPid1 = inf1->GetPDGPid(); const Int_t ktPid2 = inf2->GetPDGPid(); if (((ktPid1 == 211) && (ktPid2 == 211)) || ((ktPid1 == -211) && (ktPid2 == -211))) - fPairType = fgkPionPlusPionPlus; + tPairType = fgkPionPlusPionPlus; else if (((ktPid1 == -211) && (ktPid2 == 211)) || ((ktPid1 == 211) && (ktPid2 == -211))) - fPairType = fgkPionPlusPionMinus; + tPairType = fgkPionPlusPionMinus; else if (((ktPid1 == 321) && (ktPid2 == 321)) || ((ktPid1 == -321) && (ktPid2 == -321))) - fPairType = fgkKaonPlusKaonPlus; + tPairType = fgkKaonPlusKaonPlus; else if (((ktPid1 == -321) && (ktPid2 == 321)) || ((ktPid1 == 321) && (ktPid2 == -321))) - fPairType = fgkKaonPlusKaonMinus; + tPairType = fgkKaonPlusKaonMinus; else if (((ktPid1 == 2212) && (ktPid2 == 2212)) || ((ktPid1 == -2212) && (ktPid2 == -2212))) - fPairType = fgkProtonProton; + tPairType = fgkProtonProton; else if (((ktPid1 == -2212) && (ktPid2 == 2212)) || ((ktPid1 == 2212) && (ktPid2 == -2212))) - fPairType = fgkProtonAntiproton; + tPairType = fgkProtonAntiproton; else if (((ktPid1 == 211) && (ktPid2 == 321)) || ((ktPid1 == -211) && (ktPid2 == -321))) - fPairType = fgkPionPlusKaonPlus; + tPairType = fgkPionPlusKaonPlus; else if (((ktPid1 == -211) && (ktPid2 == 321)) || ((ktPid1 == 211) && (ktPid2 == -321))) - fPairType = fgkPionPlusKaonMinus; + tPairType = fgkPionPlusKaonMinus; else if (((ktPid1 == 211) && (ktPid2 == 2212)) || ((ktPid1 == -211) && (ktPid2 == -2212))) - fPairType = fgkPionPlusProton; + tPairType = fgkPionPlusProton; else if (((ktPid1 == -211) && (ktPid2 == 2212)) || ((ktPid1 == 211) && (ktPid2 == -2212))) - fPairType = fgkPionPlusAntiproton; + tPairType = fgkPionPlusAntiproton; else if (((ktPid1 == 321) && (ktPid2 == 2212)) || ((ktPid1 == -321) && (ktPid2 == -2212))) - fPairType = fgkKaonPlusProton; + tPairType = fgkKaonPlusProton; else if (((ktPid1 == -321) && (ktPid2 == 2212)) || ((ktPid1 == 321) && (ktPid2 == -2212))) - fPairType = fgkKaonPlusAntiproton; + tPairType = fgkKaonPlusAntiproton; + + return tPairType; } //_____________________________________________ diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelWeightGenerator.h b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelWeightGenerator.h index e997c45d5c8..fe3a1e70c3e 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelWeightGenerator.h +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelWeightGenerator.h @@ -22,6 +22,7 @@ class AliFemtoModelWeightGenerator virtual void SetPairType(Int_t aPairType); virtual void SetPairTypeFromPair(AliFemtoPair *aPair); virtual Int_t GetPairType() const; + virtual Int_t GetPairTypeFromPair(AliFemtoPair *aPair); virtual Double_t GetKStar() const; virtual Double_t GetKStarOut() const; @@ -46,8 +47,10 @@ class AliFemtoModelWeightGenerator static Int_t PionPlusAntiproton(); static Int_t KaonPlusProton(); static Int_t KaonPlusAntiproton(); + static Int_t PairTypeNone(); protected: + static const Int_t fgkPairTypeNone; // no pair type set - read from model static const Int_t fgkPionPlusPionPlus; // identical pion pair static const Int_t fgkPionPlusPionMinus; // non-identical pion pair static const Int_t fgkKaonPlusKaonPlus; // identical kaon pair @@ -89,6 +92,7 @@ inline Double_t AliFemtoModelWeightGenerator::GetRStarOut() const { return fRSta inline Double_t AliFemtoModelWeightGenerator::GetRStarSide() const { return fRStarSide; } inline Double_t AliFemtoModelWeightGenerator::GetRStarLong() const { return fRStarLong; } +inline Int_t AliFemtoModelWeightGenerator::PairTypeNone() { return fgkPairTypeNone; } inline Int_t AliFemtoModelWeightGenerator::PionPlusPionPlus() { return fgkPionPlusPionPlus; } inline Int_t AliFemtoModelWeightGenerator::PionPlusPionMinus() { return fgkPionPlusPionMinus; } inline Int_t AliFemtoModelWeightGenerator::KaonPlusKaonPlus() { return fgkKaonPlusKaonPlus; } diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelWeightGeneratorBasic.cxx b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelWeightGeneratorBasic.cxx index 49fcf2b7607..d78e68ee3e6 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelWeightGeneratorBasic.cxx +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelWeightGeneratorBasic.cxx @@ -143,12 +143,24 @@ Double_t AliFemtoModelWeightGeneratorBasic::GenerateWeight(AliFemtoPair *aPair) fKStar = ::sqrt(fKStarOut*fKStarOut + fKStarSide*fKStarSide + fKStarLong*fKStarLong); // Double_t tRSt = fRStar/0.197327; - if ((fPairType == AliFemtoModelWeightGenerator::fgkPionPlusPionPlus) || (fPairType == AliFemtoModelWeightGenerator::fgkKaonPlusKaonPlus)) - return 1.0 + cos (2*(fKStarOut * tROS + fKStarSide * tRSS + fKStarLong * tRLS)); - else if (fPairType == AliFemtoModelWeightGenerator::fgkProtonProton) - return 1.0 - 0.5 * cos (2*(fKStarOut * tROS + fKStarSide * tRSS + fKStarLong * tRLS)); - else - return 1.0; + if (fPairType != fgkPairTypeNone) { + if ((fPairType == PionPlusPionPlus()) || (fPairType == KaonPlusKaonPlus())) + return 1.0 + cos (2*(fKStarOut * tROS + fKStarSide * tRSS + fKStarLong * tRLS)); + else if (fPairType == ProtonProton()) + return 1.0 - 0.5 * cos (2*(fKStarOut * tROS + fKStarSide * tRSS + fKStarLong * tRLS)); + else + return 1.0; + } + else { + Int_t tPairType = GetPairTypeFromPair(aPair); + if ((tPairType == PionPlusPionPlus()) || (tPairType == KaonPlusKaonPlus())) + return 1.0 + cos (2*(fKStarOut * tROS + fKStarSide * tRSS + fKStarLong * tRLS)); + else if (tPairType == ProtonProton()) + return 1.0 - 0.5 * cos (2*(fKStarOut * tROS + fKStarSide * tRSS + fKStarLong * tRLS)); + else + return 1.0; + + } } //________________________ diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoPair.cxx b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoPair.cxx index a51eb241f19..8f4b330e12a 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoPair.cxx +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoPair.cxx @@ -595,39 +595,39 @@ double AliFemtoPair::Quality2() const { double AliFemtoPair::NominalTpcExitSeparation() const { // separation at exit from STAR TPC - AliFemtoThreeVector diff = fTrack1->NominalTpcExitPoint() - fTrack2->NominalTpcExitPoint(); + AliFemtoThreeVector diff = fTrack1->Track()->NominalTpcExitPoint() - fTrack2->Track()->NominalTpcExitPoint(); return (diff.mag()); } double AliFemtoPair::NominalTpcEntranceSeparation() const { // separation at entrance to STAR TPC - AliFemtoThreeVector diff = fTrack1->NominalTpcEntrancePoint() - fTrack2->NominalTpcEntrancePoint(); + AliFemtoThreeVector diff = fTrack1->Track()->NominalTpcEntrancePoint() - fTrack2->Track()->NominalTpcEntrancePoint(); return (diff.mag()); } -double AliFemtoPair::NominalTpcAverageSeparation() const { - // average separation in STAR TPC - AliFemtoThreeVector diff; - double tAveSep = 0.0; - int ipt = 0; - if (fTrack1->fNominalPosSample && fTrack2->fNominalPosSample){ - while (fabs(fTrack1->fNominalPosSample[ipt].x())<9999. && - fabs(fTrack1->fNominalPosSample[ipt].y())<9999. && - fabs(fTrack1->fNominalPosSample[ipt].z())<9999. && - fabs(fTrack2->fNominalPosSample[ipt].x())<9999. && - fabs(fTrack2->fNominalPosSample[ipt].y())<9999. && - fabs(fTrack2->fNominalPosSample[ipt].z())<9999. && - ipt<11 - ){ - // for (int ipt=0; ipt<11; ipt++){ - diff = fTrack1->fNominalPosSample[ipt] - fTrack2->fNominalPosSample[ipt]; - ipt++; - tAveSep += diff.mag(); - } - tAveSep = tAveSep/(ipt+1.); - return (tAveSep);} - else return -1; -} +// double AliFemtoPair::NominalTpcAverageSeparation() const { +// // average separation in STAR TPC +// AliFemtoThreeVector diff; +// double tAveSep = 0.0; +// int ipt = 0; +// if (fTrack1->fNominalPosSample && fTrack2->fNominalPosSample){ +// while (fabs(fTrack1->fNominalPosSample[ipt].x())<9999. && +// fabs(fTrack1->fNominalPosSample[ipt].y())<9999. && +// fabs(fTrack1->fNominalPosSample[ipt].z())<9999. && +// fabs(fTrack2->fNominalPosSample[ipt].x())<9999. && +// fabs(fTrack2->fNominalPosSample[ipt].y())<9999. && +// fabs(fTrack2->fNominalPosSample[ipt].z())<9999. && +// ipt<11 +// ){ +// // for (int ipt=0; ipt<11; ipt++){ +// diff = fTrack1->fNominalPosSample[ipt] - fTrack2->fNominalPosSample[ipt]; +// ipt++; +// tAveSep += diff.mag(); +// } +// tAveSep = tAveSep/(ipt+1.); +// return (tAveSep);} +// else return -1; +// } double AliFemtoPair::OpeningAngle() const { // opening angle @@ -845,359 +845,359 @@ void AliFemtoPair::CalcNonIdPar() const{ // fortran like function! faster? -double AliFemtoPair::DcaInsideTpc() const{ - // dcs inside the STAR TPC - double tMinDist=NominalTpcEntranceSeparation(); - double tExit = NominalTpcExitSeparation(); - tMinDist = (tExit>tMinDist) ? tMinDist : tExit; - double tInsideDist; - //tMinDist = 999.; - - double rMin = 60.; - double rMax = 190.; - const AliFmPhysicalHelixD& tHelix1 = fTrack1->Helix(); - const AliFmPhysicalHelixD& tHelix2 = fTrack2->Helix(); - // --- One is a line and other one a helix - //if (tHelix1.mSingularity != tHelix2.mSingularity) return -999.; - // --- 2 lines : don't care right now - //if (tHelix1.mSingularity) return -999.; - // --- 2 helix - double dx = tHelix2.XCenter() - tHelix1.XCenter(); - double dy = tHelix2.YCenter() - tHelix1.YCenter(); - double dd = ::sqrt(dx*dx + dy*dy); - double r1 = 1/tHelix1.Curvature(); - double r2 = 1/tHelix2.Curvature(); - double cosAlpha = (r1*r1 + dd*dd - r2*r2)/(2*r1*dd); +// double AliFemtoPair::DcaInsideTpc() const{ +// // dcs inside the STAR TPC +// double tMinDist=NominalTpcEntranceSeparation(); +// double tExit = NominalTpcExitSeparation(); +// tMinDist = (tExit>tMinDist) ? tMinDist : tExit; +// double tInsideDist; +// //tMinDist = 999.; + +// double rMin = 60.; +// double rMax = 190.; +// const AliFmPhysicalHelixD& tHelix1 = fTrack1->Helix(); +// const AliFmPhysicalHelixD& tHelix2 = fTrack2->Helix(); +// // --- One is a line and other one a helix +// //if (tHelix1.mSingularity != tHelix2.mSingularity) return -999.; +// // --- 2 lines : don't care right now +// //if (tHelix1.mSingularity) return -999.; +// // --- 2 helix +// double dx = tHelix2.XCenter() - tHelix1.XCenter(); +// double dy = tHelix2.YCenter() - tHelix1.YCenter(); +// double dd = ::sqrt(dx*dx + dy*dy); +// double r1 = 1/tHelix1.Curvature(); +// double r2 = 1/tHelix2.Curvature(); +// double cosAlpha = (r1*r1 + dd*dd - r2*r2)/(2*r1*dd); - double x, y, r; - double s; - if (fabs(cosAlpha) < 1) { // two solutions - double sinAlpha = sin(acos(cosAlpha)); - x = tHelix1.XCenter() + r1*(cosAlpha*dx - sinAlpha*dy)/dd; - y = tHelix1.YCenter() + r1*(sinAlpha*dx + cosAlpha*dy)/dd; - r = ::sqrt(x*x+y*y); - if( r > rMin && r < rMax && - fabs(atan2(y,x)-fTrack1->NominalTpcEntrancePoint().phi())< 0.5 - ){ // first solution inside - s = tHelix1.PathLength(x, y); - tInsideDist=tHelix2.Distance(tHelix1.At(s)); - if(tInsideDist rMin && r < rMax && - fabs(atan2(y,x)-fTrack1->NominalTpcEntrancePoint().phi())< 0.5 - ) { // second solution inside - s = tHelix1.PathLength(x, y); - tInsideDist=tHelix2.Distance(tHelix1.At(s)); - if(tInsideDistfSect[ti]==fTrack2->fSect[ti] && fTrack1->fSect[ti]!=-1){ - tDu = fabs(fTrack1->fU[ti]-fTrack2->fU[ti]); - tDz = fabs(fTrack1->fZ[ti]-fTrack2->fZ[ti]); - tN++; - if(ti<13){ - fFracOfMergedRow += (tDu0){ - fWeightedAvSep /= tN; - fFracOfMergedRow /= tN; - } - else{ - fClosestRowAtDCA = -1; - fFracOfMergedRow = -1.; - fWeightedAvSep = -1.; - } -} -double AliFemtoPair::TpcExitSeparationTrackV0Pos() const { -//________________V0 daughters exit/entrance/average separation calc. -//_______1st part is a track 2nd is a V0 considering Pos daughter +// double x, y, r; +// double s; +// if (fabs(cosAlpha) < 1) { // two solutions +// double sinAlpha = sin(acos(cosAlpha)); +// x = tHelix1.XCenter() + r1*(cosAlpha*dx - sinAlpha*dy)/dd; +// y = tHelix1.YCenter() + r1*(sinAlpha*dx + cosAlpha*dy)/dd; +// r = ::sqrt(x*x+y*y); +// if( r > rMin && r < rMax && +// fabs(atan2(y,x)-fTrack1->Track()->NominalTpcEntrancePoint().phi())< 0.5 +// ){ // first solution inside +// s = tHelix1.PathLength(x, y); +// tInsideDist=tHelix2.Distance(tHelix1.At(s)); +// if(tInsideDist rMin && r < rMax && +// fabs(atan2(y,x)-fTrack1->Track()->NominalTpcEntrancePoint().phi())< 0.5 +// ) { // second solution inside +// s = tHelix1.PathLength(x, y); +// tInsideDist=tHelix2.Distance(tHelix1.At(s)); +// if(tInsideDistfSect[ti]==fTrack2->fSect[ti] && fTrack1->fSect[ti]!=-1){ +// tDu = fabs(fTrack1->fU[ti]-fTrack2->fU[ti]); +// tDz = fabs(fTrack1->fZ[ti]-fTrack2->fZ[ti]); +// tN++; +// if(ti<13){ +// fFracOfMergedRow += (tDu0){ +// fWeightedAvSep /= tN; +// fFracOfMergedRow /= tN; +// } +// else{ +// fClosestRowAtDCA = -1; +// fFracOfMergedRow = -1.; +// fWeightedAvSep = -1.; +// } +// } +// double AliFemtoPair::TpcExitSeparationTrackV0Pos() const { +// //________________V0 daughters exit/entrance/average separation calc. +// //_______1st part is a track 2nd is a V0 considering Pos daughter - AliFemtoThreeVector diff = fTrack1->NominalTpcExitPoint() - fTrack2->TpcV0PosExitPoint(); - return (diff.mag()); -} - -double AliFemtoPair::TpcEntranceSeparationTrackV0Pos() const { -//________________V0 daughters exit/entrance/average separation calc. -//_______1st part is a track 2nd is a V0 considering Pos daughter - AliFemtoThreeVector diff = fTrack1->NominalTpcEntrancePoint() - fTrack2->TpcV0PosEntrancePoint(); - return (diff.mag()); -} - -double AliFemtoPair::TpcAverageSeparationTrackV0Pos() const { -//________________V0 daughters exit/entrance/average separation calc. -//_______1st part is a track 2nd is a V0 considering Pos daughter - AliFemtoThreeVector diff; - double tAveSep = 0.0; - int ipt = 0; - if (fTrack1->fNominalPosSample && fTrack2->fNominalPosSample){ - while (fabs(fTrack1->fNominalPosSample[ipt].x())<9999. && - fabs(fTrack1->fNominalPosSample[ipt].y())<9999. && - fabs(fTrack1->fNominalPosSample[ipt].z())<9999. && - fabs(fTrack2->fNominalPosSample[ipt].x())<9999. && - fabs(fTrack2->fNominalPosSample[ipt].y())<9999. && - fabs(fTrack2->fNominalPosSample[ipt].z())<9999. && - (ipt<11) - ){ - diff = fTrack1->fNominalPosSample[ipt] - fTrack2->fNominalPosSample[ipt]; - ipt++; - tAveSep += diff.mag(); - } - tAveSep = tAveSep/(ipt+1.); - return (tAveSep);} - else return -1; -} -double AliFemtoPair::TpcExitSeparationTrackV0Neg() const { -//_______1st part is a track 2nd is a V0 considering Neg daughter - AliFemtoThreeVector diff = fTrack1->NominalTpcExitPoint() - fTrack2->TpcV0NegExitPoint(); - return (diff.mag()); -} - -double AliFemtoPair::TpcEntranceSeparationTrackV0Neg() const { -//_______1st part is a track 2nd is a V0 considering Neg daughter - AliFemtoThreeVector diff = fTrack1->NominalTpcEntrancePoint() - fTrack2->TpcV0NegEntrancePoint(); - return (diff.mag()); -} - -double AliFemtoPair::TpcAverageSeparationTrackV0Neg() const { -//_______1st part is a track 2nd is a V0 considering Neg daughter - AliFemtoThreeVector diff; - double tAveSep = 0.0; - int ipt = 0; - if (fTrack1->fNominalPosSample && fTrack2->fTpcV0NegPosSample){ - while (fabs(fTrack1->fNominalPosSample[ipt].x())<9999. && - fabs(fTrack1->fNominalPosSample[ipt].y())<9999. && - fabs(fTrack1->fNominalPosSample[ipt].z())<9999. && - fabs(fTrack2->fTpcV0NegPosSample[ipt].x())<9999. && - fabs(fTrack2->fTpcV0NegPosSample[ipt].y())<9999. && - fabs(fTrack2->fTpcV0NegPosSample[ipt].z())<9999. && - (ipt<11) - ){ - diff = fTrack1->fNominalPosSample[ipt] - fTrack2->fTpcV0NegPosSample[ipt]; - ipt++; - tAveSep += diff.mag(); - } - tAveSep = tAveSep/(ipt+1.); - return (tAveSep);} - else return -1; -} - -double AliFemtoPair::TpcExitSeparationV0PosV0Pos() const { -//_______1st part is a V0 considering Pos daughter 2nd is a V0 considering Pos daughter - AliFemtoThreeVector diff = fTrack1->TpcV0PosExitPoint() - fTrack2->TpcV0PosExitPoint(); - return (diff.mag()); -} - -double AliFemtoPair::TpcEntranceSeparationV0PosV0Pos() const { -//_______1st part is a V0 considering Pos daughter 2nd is a V0 considering Pos daughter - AliFemtoThreeVector diff = fTrack1->TpcV0PosEntrancePoint() - fTrack2->TpcV0PosEntrancePoint(); - return (diff.mag()); -} -double AliFemtoPair::TpcAverageSeparationV0PosV0Pos() const { -//_______1st part is a V0 considering Pos daughter 2nd is a V0 considering Pos daughter - AliFemtoThreeVector diff; - double tAveSep = 0.0; - int ipt=0; - if (fTrack1->fNominalPosSample && (fTrack2->fNominalPosSample)){ - while ((fabs(fTrack1->fNominalPosSample[ipt].x())<9999.) && - (fabs(fTrack1->fNominalPosSample[ipt].y())<9999.) && - (fabs(fTrack1->fNominalPosSample[ipt].z())<9999.) && - (fabs(fTrack2->fNominalPosSample[ipt].x())<9999.) && - (fabs(fTrack2->fNominalPosSample[ipt].y())<9999.) && - (fabs(fTrack2->fNominalPosSample[ipt].z())<9999.) && - (ipt<11) - ){ - diff = fTrack1->fNominalPosSample[ipt] - fTrack2->fNominalPosSample[ipt]; - ipt++; - tAveSep += diff.mag(); - } - tAveSep = tAveSep/(ipt+1); - return (tAveSep);} - else return -1; -} - -double AliFemtoPair::TpcExitSeparationV0PosV0Neg() const { -//_______1st part is a V0 considering Pos daughter 2nd is a V0 considering Neg daughter - AliFemtoThreeVector diff = fTrack1->TpcV0PosExitPoint() - fTrack2->TpcV0NegExitPoint(); - return (diff.mag()); -} - -double AliFemtoPair::TpcEntranceSeparationV0PosV0Neg() const { -//_______1st part is a V0 considering Pos daughter 2nd is a V0 considering Neg daughter - AliFemtoThreeVector diff = fTrack1->TpcV0PosEntrancePoint() - fTrack2->TpcV0NegEntrancePoint(); - return (diff.mag()); -} -double AliFemtoPair::TpcAverageSeparationV0PosV0Neg() const { -//_______1st part is a V0 considering Pos daughter 2nd is a V0 considering Neg daughter - AliFemtoThreeVector diff; - double tAveSep = 0.0; - int ipt = 0; - if (fTrack1->fNominalPosSample && fTrack2->fTpcV0NegPosSample){ - while (fabs(fTrack1->fNominalPosSample[ipt].x())<9999. && - fabs(fTrack1->fNominalPosSample[ipt].y())<9999. && - fabs(fTrack1->fNominalPosSample[ipt].z())<9999. && - fabs(fTrack2->fTpcV0NegPosSample[ipt].x())<9999. && - fabs(fTrack2->fTpcV0NegPosSample[ipt].y())<9999. && - fabs(fTrack2->fTpcV0NegPosSample[ipt].z())<9999. && - (ipt<11) - ){ - diff = fTrack1->fNominalPosSample[ipt] - fTrack2->fTpcV0NegPosSample[ipt]; - ipt++; - tAveSep += diff.mag(); - } - tAveSep = tAveSep/(ipt+1.); - return (tAveSep);} - else return -1; -} -double AliFemtoPair::TpcExitSeparationV0NegV0Pos() const { -//_______1st part is a V0 considering Neg daughter 2nd is a V0 considering Pos daughter -// this is to check the upper case - AliFemtoThreeVector diff = fTrack1->TpcV0NegExitPoint() - fTrack2->TpcV0PosExitPoint(); - return (diff.mag()); -} - -double AliFemtoPair::TpcEntranceSeparationV0NegV0Pos() const { -//_______1st part is a V0 considering Neg daughter 2nd is a V0 considering Pos daughter -// this is to check the upper case - AliFemtoThreeVector diff = fTrack1->TpcV0NegEntrancePoint() - fTrack2->TpcV0PosEntrancePoint(); - return (diff.mag()); -} -double AliFemtoPair::TpcAverageSeparationV0NegV0Pos() const { -//_______1st part is a V0 considering Neg daughter 2nd is a V0 considering Pos daughter -// this is to check the upper case - AliFemtoThreeVector diff; - double tAveSep = 0.0; - int ipt = 0; - if ( fTrack1->fTpcV0NegPosSample && fTrack2->fNominalPosSample){ - while (fabs(fTrack1->fTpcV0NegPosSample[ipt].x())<9999. && - fabs(fTrack1->fTpcV0NegPosSample[ipt].y())<9999. && - fabs(fTrack1->fTpcV0NegPosSample[ipt].z())<9999. && - fabs(fTrack2->fNominalPosSample[ipt].x())<9999. && - fabs(fTrack2->fNominalPosSample[ipt].y())<9999. && - fabs(fTrack2->fNominalPosSample[ipt].z())<9999. && - (ipt<11) - ){ - diff = fTrack1->fTpcV0NegPosSample[ipt] - fTrack2->fNominalPosSample[ipt]; - ipt++; - tAveSep += diff.mag(); - } - tAveSep = tAveSep/(ipt+1); - return (tAveSep);} - else return -1; -} -double AliFemtoPair::TpcExitSeparationV0NegV0Neg() const { -//_______1st part is a V0 considering Neg daughter 2nd is a V0 considering Neg daughter - AliFemtoThreeVector diff = fTrack1->TpcV0NegExitPoint() - fTrack2->TpcV0NegExitPoint(); - return (diff.mag()); -} - -double AliFemtoPair::TpcEntranceSeparationV0NegV0Neg() const { -//_______1st part is a V0 considering Neg daughter 2nd is a V0 considering Neg daughter - AliFemtoThreeVector diff = fTrack1->TpcV0NegEntrancePoint() - fTrack2->TpcV0NegEntrancePoint(); - return (diff.mag()); -} -double AliFemtoPair::TpcAverageSeparationV0NegV0Neg() const { -//_______1st part is a V0 considering Neg daughter 2nd is a V0 considering Neg daughter - AliFemtoThreeVector diff; - double tAveSep = 0.0; - int ipt=0; - if (fTrack1->fTpcV0NegPosSample && fTrack2->fTpcV0NegPosSample){ - while (fabs(fTrack1->fTpcV0NegPosSample[ipt].x())<9999. && - fabs(fTrack1->fTpcV0NegPosSample[ipt].y())<9999. && - fabs(fTrack1->fTpcV0NegPosSample[ipt].z())<9999. && - fabs(fTrack2->fTpcV0NegPosSample[ipt].x())<9999. && - fabs(fTrack2->fTpcV0NegPosSample[ipt].y())<9999. && - fabs(fTrack2->fTpcV0NegPosSample[ipt].z())<9999. && - (ipt<11) - ){ - diff = fTrack1->fTpcV0NegPosSample[ipt] - fTrack2->fTpcV0NegPosSample[ipt]; - ipt++; - tAveSep += diff.mag(); - } - tAveSep = tAveSep/(ipt+1); - return (tAveSep);} - else return -1; -} - -void AliFemtoPair::CalcMergingParFctn(short* tmpMergingParNotCalculatedFctn, - float* tmpZ1,float* tmpU1, - float* tmpZ2,float* tmpU2, - int *tmpSect1,int *tmpSect2, - double* tmpFracOfMergedRow, - double* tmpClosestRowAtDCA - ) const{ -// calculate heper variables for merging - tmpMergingParNotCalculatedFctn=0; - double tDu, tDz; - int tN = 0; - *tmpFracOfMergedRow = 0.; - *tmpClosestRowAtDCA = 0.; - double tDist; - double tDistMax = 100000000.; - for(int ti=0 ; ti<45 ; ti++){ - if(tmpSect1[ti]==tmpSect2[ti] && tmpSect1[ti]!=-1){ - tDu = fabs(tmpU1[ti]-tmpU2[ti]); - tDz = fabs(tmpZ1[ti]-tmpZ2[ti]); - tN++; - if(ti<13){ - *tmpFracOfMergedRow += (tDu0){ - //fWeightedAvSep /= tN; - *tmpFracOfMergedRow /= tN; - } - else{ - *tmpClosestRowAtDCA = -1; - *tmpFracOfMergedRow = -1.; - //fWeightedAvSep = -1.; - } -} +// AliFemtoThreeVector diff = fTrack1->Track()->NominalTpcExitPoint() - fTrack2->TpcV0PosExitPoint(); +// return (diff.mag()); +// } + +// double AliFemtoPair::TpcEntranceSeparationTrackV0Pos() const { +// //________________V0 daughters exit/entrance/average separation calc. +// //_______1st part is a track 2nd is a V0 considering Pos daughter +// AliFemtoThreeVector diff = fTrack1->Track()->NominalTpcEntrancePoint() - fTrack2->TpcV0PosEntrancePoint(); +// return (diff.mag()); +// } + +// double AliFemtoPair::TpcAverageSeparationTrackV0Pos() const { +// //________________V0 daughters exit/entrance/average separation calc. +// //_______1st part is a track 2nd is a V0 considering Pos daughter +// AliFemtoThreeVector diff; +// double tAveSep = 0.0; +// int ipt = 0; +// if (fTrack1->fNominalPosSample && fTrack2->fNominalPosSample){ +// while (fabs(fTrack1->fNominalPosSample[ipt].x())<9999. && +// fabs(fTrack1->fNominalPosSample[ipt].y())<9999. && +// fabs(fTrack1->fNominalPosSample[ipt].z())<9999. && +// fabs(fTrack2->fNominalPosSample[ipt].x())<9999. && +// fabs(fTrack2->fNominalPosSample[ipt].y())<9999. && +// fabs(fTrack2->fNominalPosSample[ipt].z())<9999. && +// (ipt<11) +// ){ +// diff = fTrack1->fNominalPosSample[ipt] - fTrack2->fNominalPosSample[ipt]; +// ipt++; +// tAveSep += diff.mag(); +// } +// tAveSep = tAveSep/(ipt+1.); +// return (tAveSep);} +// else return -1; +// } +// double AliFemtoPair::TpcExitSeparationTrackV0Neg() const { +// //_______1st part is a track 2nd is a V0 considering Neg daughter +// AliFemtoThreeVector diff = fTrack1->Track()->NominalTpcExitPoint() - fTrack2->TpcV0NegExitPoint(); +// return (diff.mag()); +// } + +// double AliFemtoPair::TpcEntranceSeparationTrackV0Neg() const { +// //_______1st part is a track 2nd is a V0 considering Neg daughter +// AliFemtoThreeVector diff = fTrack1->Track()->NominalTpcEntrancePoint() - fTrack2->TpcV0NegEntrancePoint(); +// return (diff.mag()); +// } + +// double AliFemtoPair::TpcAverageSeparationTrackV0Neg() const { +// //_______1st part is a track 2nd is a V0 considering Neg daughter +// AliFemtoThreeVector diff; +// double tAveSep = 0.0; +// int ipt = 0; +// if (fTrack1->fNominalPosSample && fTrack2->fTpcV0NegPosSample){ +// while (fabs(fTrack1->fNominalPosSample[ipt].x())<9999. && +// fabs(fTrack1->fNominalPosSample[ipt].y())<9999. && +// fabs(fTrack1->fNominalPosSample[ipt].z())<9999. && +// fabs(fTrack2->fTpcV0NegPosSample[ipt].x())<9999. && +// fabs(fTrack2->fTpcV0NegPosSample[ipt].y())<9999. && +// fabs(fTrack2->fTpcV0NegPosSample[ipt].z())<9999. && +// (ipt<11) +// ){ +// diff = fTrack1->fNominalPosSample[ipt] - fTrack2->fTpcV0NegPosSample[ipt]; +// ipt++; +// tAveSep += diff.mag(); +// } +// tAveSep = tAveSep/(ipt+1.); +// return (tAveSep);} +// else return -1; +// } + +// double AliFemtoPair::TpcExitSeparationV0PosV0Pos() const { +// //_______1st part is a V0 considering Pos daughter 2nd is a V0 considering Pos daughter +// AliFemtoThreeVector diff = fTrack1->TpcV0PosExitPoint() - fTrack2->TpcV0PosExitPoint(); +// return (diff.mag()); +// } + +// double AliFemtoPair::TpcEntranceSeparationV0PosV0Pos() const { +// //_______1st part is a V0 considering Pos daughter 2nd is a V0 considering Pos daughter +// AliFemtoThreeVector diff = fTrack1->TpcV0PosEntrancePoint() - fTrack2->TpcV0PosEntrancePoint(); +// return (diff.mag()); +// } +// double AliFemtoPair::TpcAverageSeparationV0PosV0Pos() const { +// //_______1st part is a V0 considering Pos daughter 2nd is a V0 considering Pos daughter +// AliFemtoThreeVector diff; +// double tAveSep = 0.0; +// int ipt=0; +// if (fTrack1->fNominalPosSample && (fTrack2->fNominalPosSample)){ +// while ((fabs(fTrack1->fNominalPosSample[ipt].x())<9999.) && +// (fabs(fTrack1->fNominalPosSample[ipt].y())<9999.) && +// (fabs(fTrack1->fNominalPosSample[ipt].z())<9999.) && +// (fabs(fTrack2->fNominalPosSample[ipt].x())<9999.) && +// (fabs(fTrack2->fNominalPosSample[ipt].y())<9999.) && +// (fabs(fTrack2->fNominalPosSample[ipt].z())<9999.) && +// (ipt<11) +// ){ +// diff = fTrack1->fNominalPosSample[ipt] - fTrack2->fNominalPosSample[ipt]; +// ipt++; +// tAveSep += diff.mag(); +// } +// tAveSep = tAveSep/(ipt+1); +// return (tAveSep);} +// else return -1; +// } + +// double AliFemtoPair::TpcExitSeparationV0PosV0Neg() const { +// //_______1st part is a V0 considering Pos daughter 2nd is a V0 considering Neg daughter +// AliFemtoThreeVector diff = fTrack1->TpcV0PosExitPoint() - fTrack2->TpcV0NegExitPoint(); +// return (diff.mag()); +// } + +// double AliFemtoPair::TpcEntranceSeparationV0PosV0Neg() const { +// //_______1st part is a V0 considering Pos daughter 2nd is a V0 considering Neg daughter +// AliFemtoThreeVector diff = fTrack1->TpcV0PosEntrancePoint() - fTrack2->TpcV0NegEntrancePoint(); +// return (diff.mag()); +// } +// double AliFemtoPair::TpcAverageSeparationV0PosV0Neg() const { +// //_______1st part is a V0 considering Pos daughter 2nd is a V0 considering Neg daughter +// AliFemtoThreeVector diff; +// double tAveSep = 0.0; +// int ipt = 0; +// if (fTrack1->fNominalPosSample && fTrack2->fTpcV0NegPosSample){ +// while (fabs(fTrack1->fNominalPosSample[ipt].x())<9999. && +// fabs(fTrack1->fNominalPosSample[ipt].y())<9999. && +// fabs(fTrack1->fNominalPosSample[ipt].z())<9999. && +// fabs(fTrack2->fTpcV0NegPosSample[ipt].x())<9999. && +// fabs(fTrack2->fTpcV0NegPosSample[ipt].y())<9999. && +// fabs(fTrack2->fTpcV0NegPosSample[ipt].z())<9999. && +// (ipt<11) +// ){ +// diff = fTrack1->fNominalPosSample[ipt] - fTrack2->fTpcV0NegPosSample[ipt]; +// ipt++; +// tAveSep += diff.mag(); +// } +// tAveSep = tAveSep/(ipt+1.); +// return (tAveSep);} +// else return -1; +// } +// double AliFemtoPair::TpcExitSeparationV0NegV0Pos() const { +// //_______1st part is a V0 considering Neg daughter 2nd is a V0 considering Pos daughter +// // this is to check the upper case +// AliFemtoThreeVector diff = fTrack1->TpcV0NegExitPoint() - fTrack2->TpcV0PosExitPoint(); +// return (diff.mag()); +// } + +// double AliFemtoPair::TpcEntranceSeparationV0NegV0Pos() const { +// //_______1st part is a V0 considering Neg daughter 2nd is a V0 considering Pos daughter +// // this is to check the upper case +// AliFemtoThreeVector diff = fTrack1->TpcV0NegEntrancePoint() - fTrack2->TpcV0PosEntrancePoint(); +// return (diff.mag()); +// } +// double AliFemtoPair::TpcAverageSeparationV0NegV0Pos() const { +// //_______1st part is a V0 considering Neg daughter 2nd is a V0 considering Pos daughter +// // this is to check the upper case +// AliFemtoThreeVector diff; +// double tAveSep = 0.0; +// int ipt = 0; +// if ( fTrack1->fTpcV0NegPosSample && fTrack2->fNominalPosSample){ +// while (fabs(fTrack1->fTpcV0NegPosSample[ipt].x())<9999. && +// fabs(fTrack1->fTpcV0NegPosSample[ipt].y())<9999. && +// fabs(fTrack1->fTpcV0NegPosSample[ipt].z())<9999. && +// fabs(fTrack2->fNominalPosSample[ipt].x())<9999. && +// fabs(fTrack2->fNominalPosSample[ipt].y())<9999. && +// fabs(fTrack2->fNominalPosSample[ipt].z())<9999. && +// (ipt<11) +// ){ +// diff = fTrack1->fTpcV0NegPosSample[ipt] - fTrack2->fNominalPosSample[ipt]; +// ipt++; +// tAveSep += diff.mag(); +// } +// tAveSep = tAveSep/(ipt+1); +// return (tAveSep);} +// else return -1; +// } +// double AliFemtoPair::TpcExitSeparationV0NegV0Neg() const { +// //_______1st part is a V0 considering Neg daughter 2nd is a V0 considering Neg daughter +// AliFemtoThreeVector diff = fTrack1->TpcV0NegExitPoint() - fTrack2->TpcV0NegExitPoint(); +// return (diff.mag()); +// } + +// double AliFemtoPair::TpcEntranceSeparationV0NegV0Neg() const { +// //_______1st part is a V0 considering Neg daughter 2nd is a V0 considering Neg daughter +// AliFemtoThreeVector diff = fTrack1->TpcV0NegEntrancePoint() - fTrack2->TpcV0NegEntrancePoint(); +// return (diff.mag()); +// } +// double AliFemtoPair::TpcAverageSeparationV0NegV0Neg() const { +// //_______1st part is a V0 considering Neg daughter 2nd is a V0 considering Neg daughter +// AliFemtoThreeVector diff; +// double tAveSep = 0.0; +// int ipt=0; +// if (fTrack1->fTpcV0NegPosSample && fTrack2->fTpcV0NegPosSample){ +// while (fabs(fTrack1->fTpcV0NegPosSample[ipt].x())<9999. && +// fabs(fTrack1->fTpcV0NegPosSample[ipt].y())<9999. && +// fabs(fTrack1->fTpcV0NegPosSample[ipt].z())<9999. && +// fabs(fTrack2->fTpcV0NegPosSample[ipt].x())<9999. && +// fabs(fTrack2->fTpcV0NegPosSample[ipt].y())<9999. && +// fabs(fTrack2->fTpcV0NegPosSample[ipt].z())<9999. && +// (ipt<11) +// ){ +// diff = fTrack1->fTpcV0NegPosSample[ipt] - fTrack2->fTpcV0NegPosSample[ipt]; +// ipt++; +// tAveSep += diff.mag(); +// } +// tAveSep = tAveSep/(ipt+1); +// return (tAveSep);} +// else return -1; +// } + +// void AliFemtoPair::CalcMergingParFctn(short* tmpMergingParNotCalculatedFctn, +// float* tmpZ1,float* tmpU1, +// float* tmpZ2,float* tmpU2, +// int *tmpSect1,int *tmpSect2, +// double* tmpFracOfMergedRow, +// double* tmpClosestRowAtDCA +// ) const{ +// // calculate heper variables for merging +// tmpMergingParNotCalculatedFctn=0; +// double tDu, tDz; +// int tN = 0; +// *tmpFracOfMergedRow = 0.; +// *tmpClosestRowAtDCA = 0.; +// double tDist; +// double tDistMax = 100000000.; +// for(int ti=0 ; ti<45 ; ti++){ +// if(tmpSect1[ti]==tmpSect2[ti] && tmpSect1[ti]!=-1){ +// tDu = fabs(tmpU1[ti]-tmpU2[ti]); +// tDz = fabs(tmpZ1[ti]-tmpZ2[ti]); +// tN++; +// if(ti<13){ +// *tmpFracOfMergedRow += (tDu0){ +// //fWeightedAvSep /= tN; +// *tmpFracOfMergedRow /= tN; +// } +// else{ +// *tmpClosestRowAtDCA = -1; +// *tmpFracOfMergedRow = -1.; +// //fWeightedAvSep = -1.; +// } +// } diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoPair.h b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoPair.h index dfc675c1426..424ab09f8b5 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoPair.h +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoPair.h @@ -79,31 +79,31 @@ public: // assumption is important for the Event Mixing-- it is not a mistake. - MALisa double NominalTpcExitSeparation() const; double NominalTpcEntranceSeparation() const; - double NominalTpcAverageSeparation() const; + // double NominalTpcAverageSeparation() const; // adapted calculation of Entrance/Exit/Average Tpc separation to V0 daughters - double TpcExitSeparationTrackV0Pos() const; - double TpcEntranceSeparationTrackV0Pos() const; - double TpcAverageSeparationTrackV0Pos() const; +/* double TpcExitSeparationTrackV0Pos() const; */ +/* double TpcEntranceSeparationTrackV0Pos() const; */ +/* double TpcAverageSeparationTrackV0Pos() const; */ - double TpcExitSeparationTrackV0Neg() const; - double TpcEntranceSeparationTrackV0Neg() const; - double TpcAverageSeparationTrackV0Neg() const; +/* double TpcExitSeparationTrackV0Neg() const; */ +/* double TpcEntranceSeparationTrackV0Neg() const; */ +/* double TpcAverageSeparationTrackV0Neg() const; */ - double TpcExitSeparationV0PosV0Pos() const; - double TpcEntranceSeparationV0PosV0Pos() const; - double TpcAverageSeparationV0PosV0Pos() const; +/* double TpcExitSeparationV0PosV0Pos() const; */ +/* double TpcEntranceSeparationV0PosV0Pos() const; */ +/* double TpcAverageSeparationV0PosV0Pos() const; */ - double TpcExitSeparationV0PosV0Neg() const; - double TpcEntranceSeparationV0PosV0Neg() const; - double TpcAverageSeparationV0PosV0Neg() const; +/* double TpcExitSeparationV0PosV0Neg() const; */ +/* double TpcEntranceSeparationV0PosV0Neg() const; */ +/* double TpcAverageSeparationV0PosV0Neg() const; */ - double TpcExitSeparationV0NegV0Pos() const; - double TpcEntranceSeparationV0NegV0Pos() const; - double TpcAverageSeparationV0NegV0Pos() const; +/* double TpcExitSeparationV0NegV0Pos() const; */ +/* double TpcEntranceSeparationV0NegV0Pos() const; */ +/* double TpcAverageSeparationV0NegV0Pos() const; */ - double TpcExitSeparationV0NegV0Neg() const; - double TpcEntranceSeparationV0NegV0Neg() const; - double TpcAverageSeparationV0NegV0Neg() const; +/* double TpcExitSeparationV0NegV0Neg() const; */ +/* double TpcEntranceSeparationV0NegV0Neg() const; */ +/* double TpcAverageSeparationV0NegV0Neg() const; */ double PInv() const; double KStar() const; @@ -142,16 +142,16 @@ public: double GetClosestRowAtDCA() const; double GetWeightedAvSep() const; // >>> - double GetFracOfMergedRowTrkV0Pos() const; - double GetClosestRowAtDCATrkV0Pos() const; +/* double GetFracOfMergedRowTrkV0Pos() const; */ +/* double GetClosestRowAtDCATrkV0Pos() const; */ - double GetFracOfMergedRowTrkV0Neg() const; - double GetClosestRowAtDCATrkV0Neg() const; +/* double GetFracOfMergedRowTrkV0Neg() const; */ +/* double GetClosestRowAtDCATrkV0Neg() const; */ - double GetFracOfMergedRowV0PosV0Neg() const; - double GetFracOfMergedRowV0NegV0Pos() const; - double GetFracOfMergedRowV0PosV0Pos() const; - double GetFracOfMergedRowV0NegV0Neg() const; +/* double GetFracOfMergedRowV0PosV0Neg() const; */ +/* double GetFracOfMergedRowV0NegV0Pos() const; */ +/* double GetFracOfMergedRowV0PosV0Pos() const; */ +/* double GetFracOfMergedRowV0NegV0Neg() const; */ private: AliFemtoParticle* fTrack1; // Link to the first track in the pair @@ -317,92 +317,92 @@ inline double AliFemtoPair::GetWeightedAvSep() const { } -inline double AliFemtoPair::GetFracOfMergedRowTrkV0Pos() const{ - if(fMergingParNotCalculatedTrkV0Pos) - CalcMergingParFctn(&fMergingParNotCalculatedTrkV0Pos, - &(fTrack1->fZ[0]),&(fTrack1->fU[0]), - &(fTrack2->fZ[0]),&(fTrack2->fU[0]), - &(fTrack1->fSect[0]),&(fTrack2->fSect[0]), - &(fFracOfMergedRowTrkV0Pos),&(fClosestRowAtDCATrkV0Pos) - ); - return fFracOfMergedRowTrkV0Pos; -} -inline double AliFemtoPair::GetClosestRowAtDCATrkV0Pos() const{ - if(fMergingParNotCalculatedTrkV0Pos) - CalcMergingParFctn(&fMergingParNotCalculatedTrkV0Pos, - &(fTrack1->fZ[0]),&(fTrack1->fU[0]), - &(fTrack2->fZ[0]),&(fTrack2->fU[0]), - &(fTrack1->fSect[0]),&(fTrack2->fSect[0]), - &fFracOfMergedRowTrkV0Pos,&fClosestRowAtDCATrkV0Pos - ); - return fClosestRowAtDCATrkV0Pos; -} -inline double AliFemtoPair::GetFracOfMergedRowTrkV0Neg() const{ - if(fMergingParNotCalculatedTrkV0Neg) - CalcMergingParFctn(&fMergingParNotCalculatedTrkV0Neg, - &(fTrack1->fZ[0]),&(fTrack1->fU[0]), - &(fTrack2->fV0NegZ[0]),&(fTrack2->fV0NegU[0]), - &(fTrack1->fSect[0]),&(fTrack2->fV0NegSect[0]), - &(fFracOfMergedRowTrkV0Neg),&(fClosestRowAtDCATrkV0Neg) - ); - return fFracOfMergedRowTrkV0Neg; -} -inline double AliFemtoPair::GetClosestRowAtDCATrkV0Neg() const{ - if(fMergingParNotCalculatedTrkV0Neg) - CalcMergingParFctn(&fMergingParNotCalculatedTrkV0Neg, - &(fTrack1->fZ[0]),&(fTrack1->fU[0]), - &(fTrack2->fV0NegZ[0]),&(fTrack2->fV0NegU[0]), - &(fTrack1->fSect[0]),&(fTrack2->fV0NegSect[0]), - &fFracOfMergedRowTrkV0Neg,&fClosestRowAtDCATrkV0Neg - ); - return fClosestRowAtDCATrkV0Neg; -} -inline double AliFemtoPair::GetFracOfMergedRowV0PosV0Neg() const{ - if(fMergingParNotCalculatedV0PosV0Neg) - CalcMergingParFctn(&fMergingParNotCalculatedV0PosV0Neg, - &(fTrack1->fZ[0]),&(fTrack1->fU[0]), - &(fTrack2->fV0NegZ[0]),&(fTrack2->fV0NegU[0]), - &(fTrack1->fSect[0]),&(fTrack2->fV0NegSect[0]), - &(fFracOfMergedRowV0PosV0Neg), - &(fClosestRowAtDCAV0PosV0Neg) - ); - return fFracOfMergedRowV0PosV0Neg; -} -inline double AliFemtoPair::GetFracOfMergedRowV0NegV0Pos() const{ - if(fMergingParNotCalculatedV0NegV0Pos) - CalcMergingParFctn(&fMergingParNotCalculatedV0NegV0Pos, - &(fTrack1->fV0NegZ[0]),&(fTrack1->fV0NegU[0]), - &(fTrack2->fZ[0]),&(fTrack2->fU[0]), - &(fTrack1->fV0NegSect[0]), - &(fTrack2->fSect[0]), - &(fFracOfMergedRowV0NegV0Pos), - &(fClosestRowAtDCAV0NegV0Pos) - ); - return fFracOfMergedRowV0NegV0Pos; -} -inline double AliFemtoPair::GetFracOfMergedRowV0PosV0Pos() const{ - if(fMergingParNotCalculatedV0PosV0Pos) - CalcMergingParFctn(&fMergingParNotCalculatedV0PosV0Pos, - &(fTrack1->fZ[0]),&(fTrack1->fU[0]), - &(fTrack2->fZ[0]),&(fTrack2->fU[0]), - &(fTrack1->fSect[0]), - &(fTrack2->fSect[0]), - &(fFracOfMergedRowV0PosV0Pos), - &(fClosestRowAtDCAV0PosV0Pos) - ); - return fFracOfMergedRowV0PosV0Pos; -} -inline double AliFemtoPair::GetFracOfMergedRowV0NegV0Neg() const{ - if(fMergingParNotCalculatedV0NegV0Neg) - CalcMergingParFctn(&fMergingParNotCalculatedV0NegV0Neg, - &(fTrack1->fV0NegZ[0]),&(fTrack1->fV0NegU[0]), - &(fTrack2->fV0NegZ[0]),&(fTrack2->fV0NegU[0]), - &(fTrack1->fV0NegSect[0]), - &(fTrack2->fV0NegSect[0]), - &(fFracOfMergedRowV0NegV0Neg), - &(fClosestRowAtDCAV0NegV0Neg) - ); - return fFracOfMergedRowV0NegV0Neg; -} +/* inline double AliFemtoPair::GetFracOfMergedRowTrkV0Pos() const{ */ +/* if(fMergingParNotCalculatedTrkV0Pos) */ +/* CalcMergingParFctn(&fMergingParNotCalculatedTrkV0Pos, */ +/* &(fTrack1->fZ[0]),&(fTrack1->fU[0]), */ +/* &(fTrack2->fZ[0]),&(fTrack2->fU[0]), */ +/* &(fTrack1->fSect[0]),&(fTrack2->fSect[0]), */ +/* &(fFracOfMergedRowTrkV0Pos),&(fClosestRowAtDCATrkV0Pos) */ +/* ); */ +/* return fFracOfMergedRowTrkV0Pos; */ +/* } */ +/* inline double AliFemtoPair::GetClosestRowAtDCATrkV0Pos() const{ */ +/* if(fMergingParNotCalculatedTrkV0Pos) */ +/* CalcMergingParFctn(&fMergingParNotCalculatedTrkV0Pos, */ +/* &(fTrack1->fZ[0]),&(fTrack1->fU[0]), */ +/* &(fTrack2->fZ[0]),&(fTrack2->fU[0]), */ +/* &(fTrack1->fSect[0]),&(fTrack2->fSect[0]), */ +/* &fFracOfMergedRowTrkV0Pos,&fClosestRowAtDCATrkV0Pos */ +/* ); */ +/* return fClosestRowAtDCATrkV0Pos; */ +/* } */ +/* inline double AliFemtoPair::GetFracOfMergedRowTrkV0Neg() const{ */ +/* if(fMergingParNotCalculatedTrkV0Neg) */ +/* CalcMergingParFctn(&fMergingParNotCalculatedTrkV0Neg, */ +/* &(fTrack1->fZ[0]),&(fTrack1->fU[0]), */ +/* &(fTrack2->fV0NegZ[0]),&(fTrack2->fV0NegU[0]), */ +/* &(fTrack1->fSect[0]),&(fTrack2->fV0NegSect[0]), */ +/* &(fFracOfMergedRowTrkV0Neg),&(fClosestRowAtDCATrkV0Neg) */ +/* ); */ +/* return fFracOfMergedRowTrkV0Neg; */ +/* } */ +/* inline double AliFemtoPair::GetClosestRowAtDCATrkV0Neg() const{ */ +/* if(fMergingParNotCalculatedTrkV0Neg) */ +/* CalcMergingParFctn(&fMergingParNotCalculatedTrkV0Neg, */ +/* &(fTrack1->fZ[0]),&(fTrack1->fU[0]), */ +/* &(fTrack2->fV0NegZ[0]),&(fTrack2->fV0NegU[0]), */ +/* &(fTrack1->fSect[0]),&(fTrack2->fV0NegSect[0]), */ +/* &fFracOfMergedRowTrkV0Neg,&fClosestRowAtDCATrkV0Neg */ +/* ); */ +/* return fClosestRowAtDCATrkV0Neg; */ +/* } */ +/* inline double AliFemtoPair::GetFracOfMergedRowV0PosV0Neg() const{ */ +/* if(fMergingParNotCalculatedV0PosV0Neg) */ +/* CalcMergingParFctn(&fMergingParNotCalculatedV0PosV0Neg, */ +/* &(fTrack1->fZ[0]),&(fTrack1->fU[0]), */ +/* &(fTrack2->fV0NegZ[0]),&(fTrack2->fV0NegU[0]), */ +/* &(fTrack1->fSect[0]),&(fTrack2->fV0NegSect[0]), */ +/* &(fFracOfMergedRowV0PosV0Neg), */ +/* &(fClosestRowAtDCAV0PosV0Neg) */ +/* ); */ +/* return fFracOfMergedRowV0PosV0Neg; */ +/* } */ +/* inline double AliFemtoPair::GetFracOfMergedRowV0NegV0Pos() const{ */ +/* if(fMergingParNotCalculatedV0NegV0Pos) */ +/* CalcMergingParFctn(&fMergingParNotCalculatedV0NegV0Pos, */ +/* &(fTrack1->fV0NegZ[0]),&(fTrack1->fV0NegU[0]), */ +/* &(fTrack2->fZ[0]),&(fTrack2->fU[0]), */ +/* &(fTrack1->fV0NegSect[0]), */ +/* &(fTrack2->fSect[0]), */ +/* &(fFracOfMergedRowV0NegV0Pos), */ +/* &(fClosestRowAtDCAV0NegV0Pos) */ +/* ); */ +/* return fFracOfMergedRowV0NegV0Pos; */ +/* } */ +/* inline double AliFemtoPair::GetFracOfMergedRowV0PosV0Pos() const{ */ +/* if(fMergingParNotCalculatedV0PosV0Pos) */ +/* CalcMergingParFctn(&fMergingParNotCalculatedV0PosV0Pos, */ +/* &(fTrack1->fZ[0]),&(fTrack1->fU[0]), */ +/* &(fTrack2->fZ[0]),&(fTrack2->fU[0]), */ +/* &(fTrack1->fSect[0]), */ +/* &(fTrack2->fSect[0]), */ +/* &(fFracOfMergedRowV0PosV0Pos), */ +/* &(fClosestRowAtDCAV0PosV0Pos) */ +/* ); */ +/* return fFracOfMergedRowV0PosV0Pos; */ +/* } */ +/* inline double AliFemtoPair::GetFracOfMergedRowV0NegV0Neg() const{ */ +/* if(fMergingParNotCalculatedV0NegV0Neg) */ +/* CalcMergingParFctn(&fMergingParNotCalculatedV0NegV0Neg, */ +/* &(fTrack1->fV0NegZ[0]),&(fTrack1->fV0NegU[0]), */ +/* &(fTrack2->fV0NegZ[0]),&(fTrack2->fV0NegU[0]), */ +/* &(fTrack1->fV0NegSect[0]), */ +/* &(fTrack2->fV0NegSect[0]), */ +/* &(fFracOfMergedRowV0NegV0Neg), */ +/* &(fClosestRowAtDCAV0NegV0Neg) */ +/* ); */ +/* return fFracOfMergedRowV0NegV0Neg; */ +/* } */ #endif diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoParticle.cxx b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoParticle.cxx index 41b425f7d62..19dca545b55 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoParticle.cxx +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoParticle.cxx @@ -41,15 +41,15 @@ int TpcLocalTransform(AliFmThreeVectorD& xgl, //_____________________ AliFemtoParticle::AliFemtoParticle() : - fTpcV0NegPosSample(0), - fV0NegZ(0), - fV0NegU(0), - fV0NegSect(0), +// fTpcV0NegPosSample(0), +// fV0NegZ(0), +// fV0NegU(0), +// fV0NegSect(0), fTrack(0), fV0(0), fKink(0), fXi(0), fFourMomentum(0), fHelix(), - fNominalTpcExitPoint(0), - fNominalTpcEntrancePoint(0), +// fNominalTpcExitPoint(0), +// fNominalTpcEntrancePoint(0), fHiddenInfo(0), fPrimaryVertex(0), fSecondaryVertex(0), @@ -66,15 +66,15 @@ AliFemtoParticle::AliFemtoParticle() : } //_____________________ AliFemtoParticle::AliFemtoParticle(const AliFemtoParticle& aParticle): - fTpcV0NegPosSample(0), - fV0NegZ(0), - fV0NegU(0), - fV0NegSect(0), +// fTpcV0NegPosSample(0), +// fV0NegZ(0), +// fV0NegU(0), +// fV0NegSect(0), fTrack(0), fV0(0), fKink(0), fXi(0), fFourMomentum(0), fHelix(), - fNominalTpcExitPoint(0), - fNominalTpcEntrancePoint(0), +// fNominalTpcExitPoint(0), +// fNominalTpcEntrancePoint(0), fHiddenInfo(0), fPrimaryVertex(0), fSecondaryVertex(0), @@ -97,30 +97,30 @@ AliFemtoParticle::AliFemtoParticle(const AliFemtoParticle& aParticle): fFourMomentum = aParticle.fFourMomentum; fHelix = aParticle.fHelix; - for (int iter=0; iter<11; iter++) - fNominalPosSample[iter] = aParticle.fNominalPosSample[iter]; - - if (aParticle.fTpcV0NegPosSample) { - fTpcV0NegPosSample = (AliFemtoThreeVector *) malloc(sizeof(AliFemtoThreeVector) * 11); - for (int iter=0; iter<11; iter++) - fTpcV0NegPosSample[iter] = aParticle.fTpcV0NegPosSample[iter]; - } - - if (aParticle.fV0NegZ) { - fV0NegZ = (float *) malloc(sizeof(float) * 45); - for (int iter=0; iter<11; iter++) - fV0NegZ[iter] = aParticle.fV0NegZ[iter]; - } - if (aParticle.fV0NegU) { - fV0NegU = (float *) malloc(sizeof(float) * 45); - for (int iter=0; iter<11; iter++) - fV0NegU[iter] = aParticle.fV0NegU[iter]; - } - if (aParticle.fV0NegSect) { - fV0NegSect = (int *) malloc(sizeof(int) * 45); - for (int iter=0; iter<11; iter++) - fV0NegSect[iter] = aParticle.fV0NegSect[iter]; - } +// for (int iter=0; iter<11; iter++) +// fNominalPosSample[iter] = aParticle.fNominalPosSample[iter]; + +// if (aParticle.fTpcV0NegPosSample) { +// fTpcV0NegPosSample = (AliFemtoThreeVector *) malloc(sizeof(AliFemtoThreeVector) * 11); +// for (int iter=0; iter<11; iter++) +// fTpcV0NegPosSample[iter] = aParticle.fTpcV0NegPosSample[iter]; +// } + +// if (aParticle.fV0NegZ) { +// fV0NegZ = (float *) malloc(sizeof(float) * 45); +// for (int iter=0; iter<11; iter++) +// fV0NegZ[iter] = aParticle.fV0NegZ[iter]; +// } +// if (aParticle.fV0NegU) { +// fV0NegU = (float *) malloc(sizeof(float) * 45); +// for (int iter=0; iter<11; iter++) +// fV0NegU[iter] = aParticle.fV0NegU[iter]; +// } +// if (aParticle.fV0NegSect) { +// fV0NegSect = (int *) malloc(sizeof(int) * 45); +// for (int iter=0; iter<11; iter++) +// fV0NegSect[iter] = aParticle.fV0NegSect[iter]; +// } fPrimaryVertex = aParticle.fPrimaryVertex; fSecondaryVertex = aParticle.fSecondaryVertex; @@ -129,8 +129,8 @@ AliFemtoParticle::AliFemtoParticle(const AliFemtoParticle& aParticle): fHiddenInfo= aParticle.HiddenInfo()->Clone(); } - fNominalTpcEntrancePoint = aParticle.fNominalTpcEntrancePoint; - fNominalTpcExitPoint = aParticle.fNominalTpcExitPoint; +// fNominalTpcEntrancePoint = aParticle.fNominalTpcEntrancePoint; +// fNominalTpcExitPoint = aParticle.fNominalTpcExitPoint; for (int iter=0; iter<6; iter++) fPurity[iter] = aParticle.fPurity[iter]; @@ -148,10 +148,10 @@ AliFemtoParticle::~AliFemtoParticle(){ if (fTrack) delete fTrack; if (fV0) { - delete[] fTpcV0NegPosSample; - delete[] fV0NegZ; - delete[] fV0NegU; - delete[] fV0NegSect; +// delete[] fTpcV0NegPosSample; +// delete[] fV0NegZ; +// delete[] fV0NegU; +// delete[] fV0NegSect; delete fV0; } if (fKink) delete fKink; @@ -165,15 +165,15 @@ AliFemtoParticle::~AliFemtoParticle(){ } //_____________________ AliFemtoParticle::AliFemtoParticle(const AliFemtoTrack* const hbtTrack,const double& mass) : - fTpcV0NegPosSample(0), - fV0NegZ(0), - fV0NegU(0), - fV0NegSect(0), +// fTpcV0NegPosSample(0), +// fV0NegZ(0), +// fV0NegU(0), +// fV0NegSect(0), fTrack(0), fV0(0), fKink(0), fXi(0), fFourMomentum(0), fHelix(), - fNominalTpcExitPoint(0), - fNominalTpcEntrancePoint(0), +// fNominalTpcExitPoint(0), +// fNominalTpcEntrancePoint(0), fHiddenInfo(0), fPrimaryVertex(0), fSecondaryVertex(0), @@ -227,15 +227,15 @@ AliFemtoParticle::AliFemtoParticle(const AliFemtoTrack* const hbtTrack,const dou } //_____________________ AliFemtoParticle::AliFemtoParticle(const AliFemtoV0* const hbtV0,const double& mass) : - fTpcV0NegPosSample(0), - fV0NegZ(0), - fV0NegU(0), - fV0NegSect(0), +// fTpcV0NegPosSample(0), +// fV0NegZ(0), +// fV0NegU(0), +// fV0NegSect(0), fTrack(0), fV0(0), fKink(0), fXi(0), fFourMomentum(0), fHelix(), - fNominalTpcExitPoint(0), - fNominalTpcEntrancePoint(0), +// fNominalTpcExitPoint(0), +// fNominalTpcEntrancePoint(0), fHiddenInfo(0), fPrimaryVertex(0), fSecondaryVertex(0), @@ -260,27 +260,27 @@ AliFemtoParticle::AliFemtoParticle(const AliFemtoV0* const hbtV0,const double& m fSecondaryVertex = hbtV0->DecayVertexV0(); fHelixV0Pos = hbtV0->HelixPos(); - fTpcV0NegPosSample = new AliFemtoThreeVector[45];//for V0Neg - fV0NegZ = new float[45];//for V0Neg - fV0NegU = new float[45];//for V0Neg - fV0NegSect = new int[45];//for V0Neg - CalculateTpcExitAndEntrancePoints(&fHelixV0Pos,&fPrimaryVertex, - &fSecondaryVertex, - &fTpcV0PosEntrancePoint, - &fTpcV0PosExitPoint, - &fNominalPosSample[0], - &fZ[0], - &fU[0],&fSect[0]); +// fTpcV0NegPosSample = new AliFemtoThreeVector[45];//for V0Neg +// fV0NegZ = new float[45];//for V0Neg +// fV0NegU = new float[45];//for V0Neg +// fV0NegSect = new int[45];//for V0Neg +// CalculateTpcExitAndEntrancePoints(&fHelixV0Pos,&fPrimaryVertex, +// &fSecondaryVertex, +// &fTpcV0PosEntrancePoint, +// &fTpcV0PosExitPoint, +// &fNominalPosSample[0], +// &fZ[0], +// &fU[0],&fSect[0]); fHelixV0Neg = hbtV0->HelixNeg(); - CalculateTpcExitAndEntrancePoints(&fHelixV0Neg, - &fPrimaryVertex, - &fSecondaryVertex, - &fTpcV0NegEntrancePoint, - &fTpcV0NegExitPoint, - &fTpcV0NegPosSample[0], - &fV0NegZ[0], - &fV0NegU[0],&fV0NegSect[0]); +// CalculateTpcExitAndEntrancePoints(&fHelixV0Neg, +// &fPrimaryVertex, +// &fSecondaryVertex, +// &fTpcV0NegEntrancePoint, +// &fTpcV0NegExitPoint, +// &fTpcV0NegPosSample[0], +// &fV0NegZ[0], +// &fV0NegU[0],&fV0NegSect[0]); // *** fHiddenInfo= 0; @@ -291,15 +291,15 @@ AliFemtoParticle::AliFemtoParticle(const AliFemtoV0* const hbtV0,const double& m } //_____________________ AliFemtoParticle::AliFemtoParticle(const AliFemtoKink* const hbtKink,const double& mass) : - fTpcV0NegPosSample(0), - fV0NegZ(0), - fV0NegU(0), - fV0NegSect(0), +// fTpcV0NegPosSample(0), +// fV0NegZ(0), +// fV0NegU(0), +// fV0NegSect(0), fTrack(0), fV0(0), fKink(0), fXi(0), fFourMomentum(0), fHelix(), - fNominalTpcExitPoint(0), - fNominalTpcEntrancePoint(0), +// fNominalTpcExitPoint(0), +// fNominalTpcEntrancePoint(0), fHiddenInfo(0), fPrimaryVertex(0), fSecondaryVertex(0), @@ -323,15 +323,15 @@ AliFemtoParticle::AliFemtoParticle(const AliFemtoKink* const hbtKink,const doubl //_____________________ AliFemtoParticle::AliFemtoParticle(const AliFemtoXi* const hbtXi, const double& mass) : - fTpcV0NegPosSample(0), - fV0NegZ(0), - fV0NegU(0), - fV0NegSect(0), +// fTpcV0NegPosSample(0), +// fV0NegZ(0), +// fV0NegU(0), +// fV0NegSect(0), fTrack(0), fV0(0), fKink(0), fXi(0), fFourMomentum(0), fHelix(), - fNominalTpcExitPoint(0), - fNominalTpcEntrancePoint(0), +// fNominalTpcExitPoint(0), +// fNominalTpcEntrancePoint(0), fHiddenInfo(0), fPrimaryVertex(0), fSecondaryVertex(0), @@ -370,34 +370,34 @@ AliFemtoParticle& AliFemtoParticle::operator=(const AliFemtoParticle& aParticle) fFourMomentum = aParticle.fFourMomentum; fHelix = aParticle.fHelix; - for (int iter=0; iter<11; iter++) - fNominalPosSample[iter] = aParticle.fNominalPosSample[iter]; - - if (fTpcV0NegPosSample) delete fTpcV0NegPosSample; - if (aParticle.fTpcV0NegPosSample) { - fTpcV0NegPosSample = (AliFemtoThreeVector *) malloc(sizeof(AliFemtoThreeVector) * 11); - for (int iter=0; iter<11; iter++) - fTpcV0NegPosSample[iter] = aParticle.fTpcV0NegPosSample[iter]; - } - - if (fV0NegZ) delete fV0NegZ; - if (aParticle.fV0NegZ) { - fV0NegZ = (float *) malloc(sizeof(float) * 45); - for (int iter=0; iter<11; iter++) - fV0NegZ[iter] = aParticle.fV0NegZ[iter]; - } - if (fV0NegU) delete fV0NegU; - if (aParticle.fV0NegU) { - fV0NegU = (float *) malloc(sizeof(float) * 45); - for (int iter=0; iter<11; iter++) - fV0NegU[iter] = aParticle.fV0NegU[iter]; - } - if (fV0NegSect) delete fV0NegSect; - if (aParticle.fV0NegSect) { - fV0NegSect = (int *) malloc(sizeof(int) * 45); - for (int iter=0; iter<11; iter++) - fV0NegSect[iter] = aParticle.fV0NegSect[iter]; - } +// for (int iter=0; iter<11; iter++) +// fNominalPosSample[iter] = aParticle.fNominalPosSample[iter]; + +// if (fTpcV0NegPosSample) delete fTpcV0NegPosSample; +// if (aParticle.fTpcV0NegPosSample) { +// fTpcV0NegPosSample = (AliFemtoThreeVector *) malloc(sizeof(AliFemtoThreeVector) * 11); +// for (int iter=0; iter<11; iter++) +// fTpcV0NegPosSample[iter] = aParticle.fTpcV0NegPosSample[iter]; +// } + +// if (fV0NegZ) delete fV0NegZ; +// if (aParticle.fV0NegZ) { +// fV0NegZ = (float *) malloc(sizeof(float) * 45); +// for (int iter=0; iter<11; iter++) +// fV0NegZ[iter] = aParticle.fV0NegZ[iter]; +// } +// if (fV0NegU) delete fV0NegU; +// if (aParticle.fV0NegU) { +// fV0NegU = (float *) malloc(sizeof(float) * 45); +// for (int iter=0; iter<11; iter++) +// fV0NegU[iter] = aParticle.fV0NegU[iter]; +// } +// if (fV0NegSect) delete fV0NegSect; +// if (aParticle.fV0NegSect) { +// fV0NegSect = (int *) malloc(sizeof(int) * 45); +// for (int iter=0; iter<11; iter++) +// fV0NegSect[iter] = aParticle.fV0NegSect[iter]; +// } fPrimaryVertex = aParticle.fPrimaryVertex; fSecondaryVertex = aParticle.fSecondaryVertex; @@ -406,9 +406,9 @@ AliFemtoParticle& AliFemtoParticle::operator=(const AliFemtoParticle& aParticle) fHiddenInfo= aParticle.fHiddenInfo->Clone(); } - fNominalTpcEntrancePoint = aParticle.fNominalTpcEntrancePoint; - fNominalTpcExitPoint = aParticle.fNominalTpcExitPoint; - +// fNominalTpcEntrancePoint = aParticle.fNominalTpcEntrancePoint; +// fNominalTpcExitPoint = aParticle.fNominalTpcExitPoint; + if (fHiddenInfo) delete fHiddenInfo; if (aParticle.fHiddenInfo) fHiddenInfo = aParticle.HiddenInfo()->Clone(); @@ -425,18 +425,18 @@ AliFemtoParticle& AliFemtoParticle::operator=(const AliFemtoParticle& aParticle) return *this; } -//_____________________ -const AliFemtoThreeVector& AliFemtoParticle::NominalTpcExitPoint() const{ - // in future, may want to calculate this "on demand" only, sot this routine may get more sophisticated - // for now, we calculate Exit and Entrance points upon instantiation - return fNominalTpcExitPoint; -} -//_____________________ -const AliFemtoThreeVector& AliFemtoParticle::NominalTpcEntrancePoint() const{ - // in future, may want to calculate this "on demand" only, sot this routine may get more sophisticated - // for now, we calculate Exit and Entrance points upon instantiation - return fNominalTpcEntrancePoint; -} +// //_____________________ +// const AliFemtoThreeVector& AliFemtoParticle::NominalTpcExitPoint() const{ +// // in future, may want to calculate this "on demand" only, sot this routine may get more sophisticated +// // for now, we calculate Exit and Entrance points upon instantiation +// return fNominalTpcExitPoint; +// } +// //_____________________ +// const AliFemtoThreeVector& AliFemtoParticle::NominalTpcEntrancePoint() const{ +// // in future, may want to calculate this "on demand" only, sot this routine may get more sophisticated +// // for now, we calculate Exit and Entrance points upon instantiation +// return fNominalTpcEntrancePoint; +// } //_____________________ void AliFemtoParticle::CalculatePurity(){ // Calculate additional parameterized purity @@ -483,270 +483,270 @@ double AliFemtoParticle::GetProtonPurity() return fPurity[4]; } -void AliFemtoParticle::CalculateTpcExitAndEntrancePoints(AliFmPhysicalHelixD* tHelix, - AliFemtoThreeVector* PrimVert, - AliFemtoThreeVector* SecVert, - AliFemtoThreeVector* tmpTpcEntrancePoint, - AliFemtoThreeVector* tmpTpcExitPoint, - AliFemtoThreeVector* tmpPosSample, - float* tmpZ, - float* tmpU, - int* tmpSect){ - // this calculates the exit point of a secondary track, - // either through the endcap or through the Outer Field Cage - // We assume the track to start at tHelix.origin-PrimaryVertex - // it also calculates the entrance point of the secondary track, - // which is the point at which it crosses the - // inner field cage - // static AliFemtoThreeVector ZeroVec(0.,0.,0.); - AliFemtoThreeVector tZeroVec(0.,0.,0.); -// tZeroVec.setX(tHelix->origin().x()-PrimVert->x()); -// tZeroVec.setY(tHelix->origin().y()-PrimVert->y()); -// tZeroVec.setZ(tHelix->origin().z()-PrimVert->z()); - tZeroVec.setX(SecVert->x()-PrimVert->x()); - tZeroVec.setY(SecVert->y()-PrimVert->y()); - tZeroVec.setZ(SecVert->z()-PrimVert->z()); - double dip, curv, phase; - int h; - curv = tHelix->Curvature(); - dip = tHelix->DipAngle(); - phase= tHelix->Phase(); - h = tHelix->H(); +// void AliFemtoParticle::CalculateTpcExitAndEntrancePoints(AliFmPhysicalHelixD* tHelix, +// AliFemtoThreeVector* PrimVert, +// AliFemtoThreeVector* SecVert, +// AliFemtoThreeVector* tmpTpcEntrancePoint, +// AliFemtoThreeVector* tmpTpcExitPoint, +// AliFemtoThreeVector* tmpPosSample, +// float* tmpZ, +// float* tmpU, +// int* tmpSect){ +// // this calculates the exit point of a secondary track, +// // either through the endcap or through the Outer Field Cage +// // We assume the track to start at tHelix.origin-PrimaryVertex +// // it also calculates the entrance point of the secondary track, +// // which is the point at which it crosses the +// // inner field cage +// // static AliFemtoThreeVector ZeroVec(0.,0.,0.); +// AliFemtoThreeVector tZeroVec(0.,0.,0.); +// // tZeroVec.setX(tHelix->origin().x()-PrimVert->x()); +// // tZeroVec.setY(tHelix->origin().y()-PrimVert->y()); +// // tZeroVec.setZ(tHelix->origin().z()-PrimVert->z()); +// tZeroVec.setX(SecVert->x()-PrimVert->x()); +// tZeroVec.setY(SecVert->y()-PrimVert->y()); +// tZeroVec.setZ(SecVert->z()-PrimVert->z()); +// double dip, curv, phase; +// int h; +// curv = tHelix->Curvature(); +// dip = tHelix->DipAngle(); +// phase= tHelix->Phase(); +// h = tHelix->H(); - AliFmHelixD hel(curv,dip,phase,tZeroVec,h); - - pairD candidates; - double sideLength; // this is how much length to go to leave through sides of TPC - double endLength; // this is how much length to go to leave through endcap of TPC - // figure out how far to go to leave through side... - candidates = hel.PathLength(200.0); // bugfix MAL jul00 - 200cm NOT 2cm - sideLength = (candidates.first > 0) ? candidates.first : candidates.second; - - static AliFemtoThreeVector tWestEnd(0.,0.,200.); // bugfix MAL jul00 - 200cm NOT 2cm - static AliFemtoThreeVector tEastEnd(0.,0.,-200.); // bugfix MAL jul00 - 200cm NOT 2cm - static AliFemtoThreeVector tEndCapNormal(0.,0.,1.0); - - endLength = hel.PathLength(tWestEnd,tEndCapNormal); - if (endLength < 0.0) endLength = hel.PathLength(tEastEnd,tEndCapNormal); - - if (endLength < 0.0) cout << - "AliFemtoParticle::CalculateTpcExitAndEntrancePoints(): " - << "Hey -- I cannot find an exit point out endcaps" << endl; - // OK, firstExitLength will be the shortest way out of the detector... - double firstExitLength = (endLength < sideLength) ? endLength : sideLength; - // now then, let's return the POSITION at which particle leaves TPC... - *tmpTpcExitPoint = hel.At(firstExitLength); - // Finally, calculate the position at which the track crosses the inner field cage - candidates = hel.PathLength(50.0); // bugfix MAL jul00 - 200cm NOT 2cm - - sideLength = (candidates.first > 0) ? candidates.first : candidates.second; - // cout << "sideLength 2 ="<x()) || - IsNaN(tmpTpcEntrancePoint->y()) || - IsNaN(tmpTpcEntrancePoint->z()) ){ - cout << "tmpTpcEntrancePoint NAN"<< endl; - cout << "tmpNominalTpcEntrancePoint = " <setX(-9999.); - tmpTpcEntrancePoint->setY(-9999.); - tmpTpcEntrancePoint->setZ(-9999.); - } +// AliFmHelixD hel(curv,dip,phase,tZeroVec,h); + +// pairD candidates; +// double sideLength; // this is how much length to go to leave through sides of TPC +// double endLength; // this is how much length to go to leave through endcap of TPC +// // figure out how far to go to leave through side... +// candidates = hel.PathLength(200.0); // bugfix MAL jul00 - 200cm NOT 2cm +// sideLength = (candidates.first > 0) ? candidates.first : candidates.second; + +// static AliFemtoThreeVector tWestEnd(0.,0.,200.); // bugfix MAL jul00 - 200cm NOT 2cm +// static AliFemtoThreeVector tEastEnd(0.,0.,-200.); // bugfix MAL jul00 - 200cm NOT 2cm +// static AliFemtoThreeVector tEndCapNormal(0.,0.,1.0); + +// endLength = hel.PathLength(tWestEnd,tEndCapNormal); +// if (endLength < 0.0) endLength = hel.PathLength(tEastEnd,tEndCapNormal); + +// if (endLength < 0.0) cout << +// "AliFemtoParticle::CalculateTpcExitAndEntrancePoints(): " +// << "Hey -- I cannot find an exit point out endcaps" << endl; +// // OK, firstExitLength will be the shortest way out of the detector... +// double firstExitLength = (endLength < sideLength) ? endLength : sideLength; +// // now then, let's return the POSITION at which particle leaves TPC... +// *tmpTpcExitPoint = hel.At(firstExitLength); +// // Finally, calculate the position at which the track crosses the inner field cage +// candidates = hel.PathLength(50.0); // bugfix MAL jul00 - 200cm NOT 2cm + +// sideLength = (candidates.first > 0) ? candidates.first : candidates.second; +// // cout << "sideLength 2 ="<x()) || +// IsNaN(tmpTpcEntrancePoint->y()) || +// IsNaN(tmpTpcEntrancePoint->z()) ){ +// cout << "tmpTpcEntrancePoint NAN"<< endl; +// cout << "tmpNominalTpcEntrancePoint = " <setX(-9999.); +// tmpTpcEntrancePoint->setY(-9999.); +// tmpTpcEntrancePoint->setZ(-9999.); +// } - if (IsNaN(tmpTpcExitPoint->x()) || - IsNaN(tmpTpcExitPoint->y()) || - IsNaN(tmpTpcExitPoint->z()) ) { -// cout << "tmpTpcExitPoint NAN set at (-9999,-9999,-9999)"<< endl; -// cout << "tmpTpcExitPoint X= " <x()<< endl; -// cout << "tmpTpcExitPoint Y= " <y()<< endl; -// cout << "tmpTpcExitPoint Z= " <z()<< endl; - tmpTpcExitPoint->setX(-9999.); - tmpTpcExitPoint->setY(-9999.); - tmpTpcExitPoint->setZ(-9999.); - } - - -// if (IsNaN(tmpTpcExitPoint->x())) *tmpTpcExitPoint = AliFemtoThreeVector(-9999.,-9999.,-9999); -// if (IsNaN(tmpTpcEntrancetPoint->x())) *tmpTpcEntrancePoint = AliFemtoThreeVector(-9999.,-9999.,-9999); - // cout << "tmpTpcEntrancePoint"<<*tmpTpcEntrancePoint << endl; - - // 03Oct00 - mal. OK, let's try something a little more - // along the lines of NA49 and E895 strategy. - // calculate the "nominal" position at N radii (say N=11) - // within the TPC, and for a pair cut - // use the average separation of these N - int irad = 0; - candidates = hel.PathLength(50.0); - sideLength = (candidates.first > 0) ? candidates.first : candidates.second; - while (irad<11 && !IsNaN(sideLength)){ - float radius = 50.0 + irad*15.0; - candidates = hel.PathLength(radius); - sideLength = (candidates.first > 0) ? candidates.first : candidates.second; - tmpPosSample[irad] = hel.At(sideLength); - if(IsNaN(tmpPosSample[irad].x()) || - IsNaN(tmpPosSample[irad].y()) || - IsNaN(tmpPosSample[irad].z()) - ){ - cout << "tmpPosSample for radius=" << radius << " NAN"<< endl; - cout << "tmpPosSample=(" < 0) ? candidates.first : candidates.second; - } - } - for (int i = irad; i<11; i++) - { - tmpPosSample[i] = AliFemtoThreeVector(-9999.,-9999.,-9999); - } - - static float tRowRadius[45] = {60,64.8,69.6,74.4,79.2,84,88.8,93.6,98.8, - 104,109.2,114.4,119.6,127.195,129.195,131.195, - 133.195,135.195,137.195,139.195,141.195, - 143.195,145.195,147.195,149.195,151.195, - 153.195,155.195,157.195,159.195,161.195, - 163.195,165.195,167.195,169.195,171.195, - 173.195,175.195,177.195,179.195,181.195, - 183.195,185.195,187.195,189.195}; - int tRow,tSect,tOutOfBound; - double tLength,tPhi; - float tU; - AliFemtoThreeVector tPoint; - AliFmThreeVectorD tn(0,0,0); - AliFmThreeVectorD tr(0,0,0); - int ti =0; - // test to enter the loop - candidates = hel.PathLength(tRowRadius[ti]); - tLength = (candidates.first > 0) ? candidates.first : candidates.second; - if (IsNaN(tLength)){ - cout <<"tLength Init tmp NAN" << endl; - cout <<"padrow number= "< 0) ? candidates.first : candidates.second; - if (IsNaN(tLength)){ - cout <<"tLength loop 1st NAN" << endl; - cout <<"padrow number= " << ti << " not reached" << endl; - cout << "*** THIS IS AN ERROR SHOULDN'T LOOP ***" << endl; - tmpSect[ti]=-1;//sector - } - tPoint = hel.At(tLength); - // Find which sector it is on - TpcLocalTransform(tPoint,tmpSect[ti],tRow,tU,tPhi); - if (IsNaN(tmpSect[ti])){ - cout <<"***ERROR tmpSect"<< endl; - } - if (IsNaN(tRow)){ - cout <<"***ERROR tRow"<< endl; - } - if (IsNaN(tU)){ - cout <<"***ERROR tU"<< endl; - } - if (IsNaN(tPhi)){ - cout <<"***ERROR tPhi"<< endl; - } - // calculate crossing plane - tn.setX(cos(tPhi)); - tn.setY(sin(tPhi)); - tr.setX(tRowRadius[ti]*cos(tPhi)); - tr.setY(tRowRadius[ti]*sin(tPhi)); - // find crossing point - tLength = hel.PathLength(tr,tn); - if (IsNaN(tLength)){ - cout <<"tLength loop 2nd NAN" << endl; - cout <<"padrow number= " << ti << " not reached" << endl; - tmpSect[ti]=-2;//sector - } - tPoint = hel.At(tLength); - tmpZ[ti] = tPoint.z(); - tOutOfBound = TpcLocalTransform(tPoint,tSect,tRow,tmpU[ti],tPhi); - if (IsNaN(tSect)){ - cout <<"***ERROR tSect 2"<< endl; - } - if (IsNaN(tRow)){ - cout <<"***ERROR tRow 2"<< endl; - } - if (IsNaN(tmpU[ti])){ - cout <<"***ERROR tmpU[ti] 2"<< endl; - } - if (IsNaN(tPhi)){ - cout <<"***ERROR tPhi 2 "<< endl; - } - if(tOutOfBound || (tmpSect[ti] == tSect && tRow!=(ti+1))){ - tmpSect[ti]=-2; - // cout << "missed once"<< endl; - } - else{ - if(tmpSect[ti] != tSect){ - // Try again on the other sector - tn.setX(cos(tPhi)); - tn.setY(sin(tPhi)); - tr.setX(tRowRadius[ti]*cos(tPhi)); - tr.setY(tRowRadius[ti]*sin(tPhi)); - // find crossing point - tLength = hel.PathLength(tr,tn); - tPoint = hel.At(tLength); - if (IsNaN(tLength)){ - cout <<"tLength loop 3rd NAN" << endl; - cout <<"padrow number= "<< ti << " not reached" << endl; - tmpSect[ti]=-1;//sector - } - tmpZ[ti] = tPoint.z(); - tmpSect[ti] = tSect; - tOutOfBound = TpcLocalTransform(tPoint,tSect,tRow,tmpU[ti],tPhi); - if (IsNaN(tSect)){ - cout <<"***ERROR tSect 3"<< endl; - } - if (IsNaN(tRow)){ - cout <<"***ERROR tRow 3"<< endl; - } - if (IsNaN(tmpU[ti])){ - cout <<"***ERROR tmpU[ti] 3"<< endl; - } - if (IsNaN(tPhi)){ - cout <<"***ERROR tPhi 3 "<< endl; - } - if(tOutOfBound || tSect!= tmpSect[ti] || tRow!=(ti+1)){ - tmpSect[ti]=-1; - } - } - } - if (IsNaN(tmpSect[ti])){ - cout << "*******************ERROR***************************" << endl; - cout <<"AliFemtoParticle--Fctn tmpSect=" << tmpSect[ti] << endl; - cout << "*******************ERROR***************************" << endl; - } - if (IsNaN(tmpU[ti])){ - cout << "*******************ERROR***************************" << endl; - cout <<"AliFemtoParticle--Fctn tmpU=" << tmpU[ti] << endl; - cout << "*******************ERROR***************************" << endl; - } - if (IsNaN(tmpZ[ti])){ - cout << "*******************ERROR***************************" << endl; - cout <<"AliFemtoParticle--Fctn tmpZ=" << tmpZ[ti] << endl; - cout << "*******************ERROR***************************" << endl; - } - // If padrow ti not reached all other beyond are not reached - // in this case set sector to -1 - if (tmpSect[ti]==-1){ - for (int tj=ti; tj<45;tj++){ - tmpSect[tj] = -1; - ti=45; - } - } - ti++; - if (ti<45){ - candidates = hel.PathLength(tRowRadius[ti]); - tLength = (candidates.first > 0) ? candidates.first : candidates.second;} - } -} +// if (IsNaN(tmpTpcExitPoint->x()) || +// IsNaN(tmpTpcExitPoint->y()) || +// IsNaN(tmpTpcExitPoint->z()) ) { +// // cout << "tmpTpcExitPoint NAN set at (-9999,-9999,-9999)"<< endl; +// // cout << "tmpTpcExitPoint X= " <x()<< endl; +// // cout << "tmpTpcExitPoint Y= " <y()<< endl; +// // cout << "tmpTpcExitPoint Z= " <z()<< endl; +// tmpTpcExitPoint->setX(-9999.); +// tmpTpcExitPoint->setY(-9999.); +// tmpTpcExitPoint->setZ(-9999.); +// } + + +// // if (IsNaN(tmpTpcExitPoint->x())) *tmpTpcExitPoint = AliFemtoThreeVector(-9999.,-9999.,-9999); +// // if (IsNaN(tmpTpcEntrancetPoint->x())) *tmpTpcEntrancePoint = AliFemtoThreeVector(-9999.,-9999.,-9999); +// // cout << "tmpTpcEntrancePoint"<<*tmpTpcEntrancePoint << endl; + +// // 03Oct00 - mal. OK, let's try something a little more +// // along the lines of NA49 and E895 strategy. +// // calculate the "nominal" position at N radii (say N=11) +// // within the TPC, and for a pair cut +// // use the average separation of these N +// int irad = 0; +// candidates = hel.PathLength(50.0); +// sideLength = (candidates.first > 0) ? candidates.first : candidates.second; +// while (irad<11 && !IsNaN(sideLength)){ +// float radius = 50.0 + irad*15.0; +// candidates = hel.PathLength(radius); +// sideLength = (candidates.first > 0) ? candidates.first : candidates.second; +// tmpPosSample[irad] = hel.At(sideLength); +// if(IsNaN(tmpPosSample[irad].x()) || +// IsNaN(tmpPosSample[irad].y()) || +// IsNaN(tmpPosSample[irad].z()) +// ){ +// cout << "tmpPosSample for radius=" << radius << " NAN"<< endl; +// cout << "tmpPosSample=(" < 0) ? candidates.first : candidates.second; +// } +// } +// for (int i = irad; i<11; i++) +// { +// tmpPosSample[i] = AliFemtoThreeVector(-9999.,-9999.,-9999); +// } + +// static float tRowRadius[45] = {60,64.8,69.6,74.4,79.2,84,88.8,93.6,98.8, +// 104,109.2,114.4,119.6,127.195,129.195,131.195, +// 133.195,135.195,137.195,139.195,141.195, +// 143.195,145.195,147.195,149.195,151.195, +// 153.195,155.195,157.195,159.195,161.195, +// 163.195,165.195,167.195,169.195,171.195, +// 173.195,175.195,177.195,179.195,181.195, +// 183.195,185.195,187.195,189.195}; +// int tRow,tSect,tOutOfBound; +// double tLength,tPhi; +// float tU; +// AliFemtoThreeVector tPoint; +// AliFmThreeVectorD tn(0,0,0); +// AliFmThreeVectorD tr(0,0,0); +// int ti =0; +// // test to enter the loop +// candidates = hel.PathLength(tRowRadius[ti]); +// tLength = (candidates.first > 0) ? candidates.first : candidates.second; +// if (IsNaN(tLength)){ +// cout <<"tLength Init tmp NAN" << endl; +// cout <<"padrow number= "< 0) ? candidates.first : candidates.second; +// if (IsNaN(tLength)){ +// cout <<"tLength loop 1st NAN" << endl; +// cout <<"padrow number= " << ti << " not reached" << endl; +// cout << "*** THIS IS AN ERROR SHOULDN'T LOOP ***" << endl; +// tmpSect[ti]=-1;//sector +// } +// tPoint = hel.At(tLength); +// // Find which sector it is on +// TpcLocalTransform(tPoint,tmpSect[ti],tRow,tU,tPhi); +// if (IsNaN(tmpSect[ti])){ +// cout <<"***ERROR tmpSect"<< endl; +// } +// if (IsNaN(tRow)){ +// cout <<"***ERROR tRow"<< endl; +// } +// if (IsNaN(tU)){ +// cout <<"***ERROR tU"<< endl; +// } +// if (IsNaN(tPhi)){ +// cout <<"***ERROR tPhi"<< endl; +// } +// // calculate crossing plane +// tn.setX(cos(tPhi)); +// tn.setY(sin(tPhi)); +// tr.setX(tRowRadius[ti]*cos(tPhi)); +// tr.setY(tRowRadius[ti]*sin(tPhi)); +// // find crossing point +// tLength = hel.PathLength(tr,tn); +// if (IsNaN(tLength)){ +// cout <<"tLength loop 2nd NAN" << endl; +// cout <<"padrow number= " << ti << " not reached" << endl; +// tmpSect[ti]=-2;//sector +// } +// tPoint = hel.At(tLength); +// tmpZ[ti] = tPoint.z(); +// tOutOfBound = TpcLocalTransform(tPoint,tSect,tRow,tmpU[ti],tPhi); +// if (IsNaN(tSect)){ +// cout <<"***ERROR tSect 2"<< endl; +// } +// if (IsNaN(tRow)){ +// cout <<"***ERROR tRow 2"<< endl; +// } +// if (IsNaN(tmpU[ti])){ +// cout <<"***ERROR tmpU[ti] 2"<< endl; +// } +// if (IsNaN(tPhi)){ +// cout <<"***ERROR tPhi 2 "<< endl; +// } +// if(tOutOfBound || (tmpSect[ti] == tSect && tRow!=(ti+1))){ +// tmpSect[ti]=-2; +// // cout << "missed once"<< endl; +// } +// else{ +// if(tmpSect[ti] != tSect){ +// // Try again on the other sector +// tn.setX(cos(tPhi)); +// tn.setY(sin(tPhi)); +// tr.setX(tRowRadius[ti]*cos(tPhi)); +// tr.setY(tRowRadius[ti]*sin(tPhi)); +// // find crossing point +// tLength = hel.PathLength(tr,tn); +// tPoint = hel.At(tLength); +// if (IsNaN(tLength)){ +// cout <<"tLength loop 3rd NAN" << endl; +// cout <<"padrow number= "<< ti << " not reached" << endl; +// tmpSect[ti]=-1;//sector +// } +// tmpZ[ti] = tPoint.z(); +// tmpSect[ti] = tSect; +// tOutOfBound = TpcLocalTransform(tPoint,tSect,tRow,tmpU[ti],tPhi); +// if (IsNaN(tSect)){ +// cout <<"***ERROR tSect 3"<< endl; +// } +// if (IsNaN(tRow)){ +// cout <<"***ERROR tRow 3"<< endl; +// } +// if (IsNaN(tmpU[ti])){ +// cout <<"***ERROR tmpU[ti] 3"<< endl; +// } +// if (IsNaN(tPhi)){ +// cout <<"***ERROR tPhi 3 "<< endl; +// } +// if(tOutOfBound || tSect!= tmpSect[ti] || tRow!=(ti+1)){ +// tmpSect[ti]=-1; +// } +// } +// } +// if (IsNaN(tmpSect[ti])){ +// cout << "*******************ERROR***************************" << endl; +// cout <<"AliFemtoParticle--Fctn tmpSect=" << tmpSect[ti] << endl; +// cout << "*******************ERROR***************************" << endl; +// } +// if (IsNaN(tmpU[ti])){ +// cout << "*******************ERROR***************************" << endl; +// cout <<"AliFemtoParticle--Fctn tmpU=" << tmpU[ti] << endl; +// cout << "*******************ERROR***************************" << endl; +// } +// if (IsNaN(tmpZ[ti])){ +// cout << "*******************ERROR***************************" << endl; +// cout <<"AliFemtoParticle--Fctn tmpZ=" << tmpZ[ti] << endl; +// cout << "*******************ERROR***************************" << endl; +// } +// // If padrow ti not reached all other beyond are not reached +// // in this case set sector to -1 +// if (tmpSect[ti]==-1){ +// for (int tj=ti; tj<45;tj++){ +// tmpSect[tj] = -1; +// ti=45; +// } +// } +// ti++; +// if (ti<45){ +// candidates = hel.PathLength(tRowRadius[ti]); +// tLength = (candidates.first > 0) ? candidates.first : candidates.second;} +// } +// } //_____________________ const AliFemtoThreeVector& AliFemtoParticle::TpcV0PosExitPoint() const{ return fTpcV0PosExitPoint; diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoParticle.h b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoParticle.h index b351f7f6606..bd5d5aabc35 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoParticle.h +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoParticle.h @@ -46,8 +46,8 @@ public: AliFemtoV0* V0() const; AliFemtoKink* Kink() const; - const AliFemtoThreeVector& NominalTpcExitPoint() const; // position track exits TPC assuming start at (0,0,0) - const AliFemtoThreeVector& NominalTpcEntrancePoint() const; // position track crosses IFC assuming start at (0,0,0) +/* const AliFemtoThreeVector& NominalTpcExitPoint() const; // position track exits TPC assuming start at (0,0,0) */ +/* const AliFemtoThreeVector& NominalTpcEntrancePoint() const; // position track crosses IFC assuming start at (0,0,0) */ const AliFemtoThreeVector& TpcV0PosExitPoint() const; const AliFemtoThreeVector& TpcV0PosEntrancePoint() const; const AliFemtoThreeVector& TpcV0NegExitPoint() const; @@ -59,10 +59,10 @@ public: // NOTE - this requires the fHelix, so be sure this is filled - AliFemtoThreeVector fNominalPosSample[11]; // I make this public for convenience and speed of AliFemtoPair() - float fZ[45]; // Z position of cluster on padrow - float fU[45]; // U position of cluster on padrow - int fSect[45]; // Sector number of cluster on padrow +/* AliFemtoThreeVector fNominalPosSample[11]; // I make this public for convenience and speed of AliFemtoPair() */ +/* float fZ[45]; // Z position of cluster on padrow */ +/* float fU[45]; // U position of cluster on padrow */ +/* int fSect[45]; // Sector number of cluster on padrow */ void ResetFourMomentum(const AliFemtoLorentzVector& fourMomentum); @@ -74,19 +74,19 @@ public: double GetPionPurity(); double GetKaonPurity(); double GetProtonPurity(); - void CalculateTpcExitAndEntrancePoints( AliFmPhysicalHelixD* tHelix, - AliFemtoThreeVector* PrimVert, - AliFemtoThreeVector* SecVert, - AliFemtoThreeVector* tmpTpcEntrancePoint, - AliFemtoThreeVector* tmpTpcExitPoint, - AliFemtoThreeVector* tmpPosSample, - float* tmpZ,float* tmpU,int* tmpSect); +/* void CalculateTpcExitAndEntrancePoints( AliFmPhysicalHelixD* tHelix, */ +/* AliFemtoThreeVector* PrimVert, */ +/* AliFemtoThreeVector* SecVert, */ +/* AliFemtoThreeVector* tmpTpcEntrancePoint, */ +/* AliFemtoThreeVector* tmpTpcExitPoint, */ +/* AliFemtoThreeVector* tmpPosSample, */ +/* float* tmpZ,float* tmpU,int* tmpSect); */ // For V0 Neg Daugthers TpcEntrance/ExitPoints - AliFemtoThreeVector* fTpcV0NegPosSample; // Sample of TPC V0 neg - float* fV0NegZ; // Array of Neg Z cluster positions - float* fV0NegU; // Array of Neg U cluster positions - int* fV0NegSect; // Array of Neg cluster sectors +/* AliFemtoThreeVector* fTpcV0NegPosSample; // Sample of TPC V0 neg */ +/* float* fV0NegZ; // Array of Neg Z cluster positions */ +/* float* fV0NegU; // Array of Neg U cluster positions */ +/* int* fV0NegSect; // Array of Neg cluster sectors */ private: AliFemtoTrack* fTrack; // copy of the track the particle was formed of, else Null @@ -98,8 +98,8 @@ private: AliFmPhysicalHelixD fHelix; // Particle trajectory helix //unsigned long fMap[2]; //int fNhits; - AliFemtoThreeVector fNominalTpcExitPoint; // Point where particle exits TPC - AliFemtoThreeVector fNominalTpcEntrancePoint; // Point where particle enters TPC +/* AliFemtoThreeVector fNominalTpcExitPoint; // Point where particle exits TPC */ +/* AliFemtoThreeVector fNominalTpcEntrancePoint; // Point where particle enters TPC */ AliFemtoHiddenInfo* fHiddenInfo; // Fab private double fPurity[6]; // Purity variables diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoQinvCorrFctn.cxx b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoQinvCorrFctn.cxx index 31737daf82a..bf9a07cdd3a 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoQinvCorrFctn.cxx +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoQinvCorrFctn.cxx @@ -125,5 +125,22 @@ void AliFemtoQinvCorrFctn::AddMixedPair(AliFemtoPair* pair){ double tQinv = fabs(pair->QInv()); // note - qInv() will be negative for identical pairs... fDenominator->Fill(tQinv,weight); } +//____________________________ +void AliFemtoQinvCorrFctn::Write(){ + // Write out neccessary objects + fNumerator->Write(); + fDenominator->Write(); +} +//______________________________ +TList* AliFemtoQinvCorrFctn::GetOutputList() +{ + // Prepare the list of objects to be written to the output + TList *tOutputList = new TList(); + + tOutputList->Add(fNumerator); + tOutputList->Add(fDenominator); + + return tOutputList; +} diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoQinvCorrFctn.h b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoQinvCorrFctn.h index 252fb5b7880..e41f62ff66c 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoQinvCorrFctn.h +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoQinvCorrFctn.h @@ -67,6 +67,9 @@ public: TH1D* Denominator(); TH1D* Ratio(); + virtual TList* GetOutputList(); + void Write(); + private: TH1D* fNumerator; // numerator - real pairs TH1D* fDenominator; // denominator - mixed pairs diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoSimpleAnalysis.cxx b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoSimpleAnalysis.cxx index 0da04fb4483..eb72b19a093 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoSimpleAnalysis.cxx +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoSimpleAnalysis.cxx @@ -506,6 +506,7 @@ void AliFemtoSimpleAnalysis::AddEventProcessed() { //_________________________ TList* AliFemtoSimpleAnalysis::ListSettings() { + // Collect settings list TList *tListSettings = new TList(); TList *p1Cut = fFirstParticleCut->ListSettings(); @@ -540,3 +541,47 @@ TList* AliFemtoSimpleAnalysis::ListSettings() return tListSettings; } + +//_________________________ +TList* AliFemtoSimpleAnalysis::GetOutputList() +{ + // Collect the list of output objects + // to be written + TList *tOutputList = new TList(); + + TList *p1Cut = fFirstParticleCut->GetOutputList(); + + TListIter nextp1(p1Cut); + while (TObject *obj = nextp1.Next()) { + tOutputList->Add(obj); + } + + if (fSecondParticleCut != fFirstParticleCut) { + TList *p2Cut = fSecondParticleCut->GetOutputList(); + + TIter nextp2(p2Cut); + while (TObject *obj = nextp2()) { + tOutputList->Add(obj); + } + } + + TList *pairCut = fPairCut->GetOutputList(); + + TIter nextpair(pairCut); + while (TObject *obj = nextpair()) { + tOutputList->Add(obj); + } + + AliFemtoCorrFctnIterator iter; + for (iter=fCorrFctnCollection->begin(); iter!=fCorrFctnCollection->end();iter++){ + TList *tListCf = (*iter)->GetOutputList(); + + TIter nextListCf(tListCf); + while (TObject *obj = nextListCf()) { + tOutputList->Add(obj); + } + } + + return tOutputList; + +} diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoSimpleAnalysis.h b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoSimpleAnalysis.h index 3670504f0f4..c3e8ff1c20b 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoSimpleAnalysis.h +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoSimpleAnalysis.h @@ -59,7 +59,8 @@ class AliFemtoSimpleAnalysis : public AliFemtoAnalysis { bool AnalyzeIdenticalParticles() const; virtual AliFemtoString Report(); //! returns reports of all cuts applied and correlation functions being done virtual TList* ListSettings(); // return list of cut settings for the analysis - + virtual TList* GetOutputList(); // Return a TList of objects to be written as output + virtual void EventBegin(const AliFemtoEvent* TheEventToBegin); // startup for EbyE virtual void ProcessEvent(const AliFemtoEvent* EventToProcess); virtual void EventEnd(const AliFemtoEvent* TheEventToWrapUp); // cleanup for EbyE diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoTrack.cxx b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoTrack.cxx index c5c857fbff9..f145cf3539a 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoTrack.cxx +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoTrack.cxx @@ -47,8 +47,11 @@ AliFemtoTrack::AliFemtoTrack(): fTPCnclsF(0), fTPCsignalN(0), fTPCsignalS(0), + fSigmaToVertex(0), fClusters(159), fShared(159), + fNominalTpcEntrancePoint(0,0,0), + fNominalTpcExitPoint(0,0,0), fHiddenInfo(0) { // Default constructor @@ -85,8 +88,11 @@ AliFemtoTrack::AliFemtoTrack(const AliFemtoTrack& t) : fTPCnclsF(0), fTPCsignalN(0), fTPCsignalS(0), + fSigmaToVertex(0), fClusters(159), fShared(159), + fNominalTpcEntrancePoint(0,0,0), + fNominalTpcExitPoint(0,0,0), fHiddenInfo(0) { // copy constructor @@ -114,8 +120,11 @@ AliFemtoTrack::AliFemtoTrack(const AliFemtoTrack& t) : fTPCnclsF=t.fTPCnclsF; fTPCsignalN=t.fTPCsignalN; fTPCsignalS=t.fTPCsignalS; + fSigmaToVertex=t.fSigmaToVertex; fClusters=t.fClusters; fShared=t.fShared; + fNominalTpcEntrancePoint=t.fNominalTpcEntrancePoint; + fNominalTpcExitPoint=t.fNominalTpcExitPoint; if (t.ValidHiddenInfo()) fHiddenInfo = t.GetHiddenInfo()->Clone(); else @@ -157,6 +166,8 @@ AliFemtoTrack& AliFemtoTrack::operator=(const AliFemtoTrack& aTrack) fTPCsignalS=aTrack.fTPCsignalS; fClusters=aTrack.fClusters; fShared=aTrack.fShared; + fNominalTpcEntrancePoint=aTrack.fNominalTpcEntrancePoint; + fNominalTpcExitPoint=aTrack.fNominalTpcExitPoint; fKinkIndexes[0] = aTrack.fKinkIndexes[0]; fKinkIndexes[1] = aTrack.fKinkIndexes[1]; fKinkIndexes[2] = aTrack.fKinkIndexes[2]; @@ -196,6 +207,7 @@ void AliFemtoTrack::SetTPCncls(const int& TPCncls){fTPCncls=TPCncls;} void AliFemtoTrack::SetTPCnclsF(const short& TPCnclsF){fTPCnclsF=TPCnclsF;} void AliFemtoTrack::SetTPCsignalN(const short& TPCsignalN){fTPCsignalN=TPCsignalN;} void AliFemtoTrack::SetTPCsignalS(const float& TPCsignalS){fTPCsignalS=TPCsignalS;} +void AliFemtoTrack::SetSigmaToVertex(const float& Sigma){fSigmaToVertex=Sigma;} short AliFemtoTrack::Charge() const {return fCharge;} @@ -217,6 +229,7 @@ int AliFemtoTrack::TPCncls() const{return fTPCncls;} short AliFemtoTrack::TPCnclsF() const{return fTPCnclsF;} short AliFemtoTrack::TPCsignalN() const{return fTPCsignalN;} float AliFemtoTrack::TPCsignalS() const{return fTPCsignalS;} +float AliFemtoTrack::SigmaToVertex() const{return fSigmaToVertex;} void AliFemtoTrack::SetHiddenInfo(AliFemtoHiddenInfo* aHiddenInfo) {fHiddenInfo=aHiddenInfo;} bool AliFemtoTrack::ValidHiddenInfo() const { if (fHiddenInfo) return true; else return false; } @@ -224,6 +237,7 @@ AliFemtoHiddenInfo* AliFemtoTrack::GetHiddenInfo() const {return fHiddenInfo;} AliFemtoTrack::~AliFemtoTrack() { + // destructor if (fHiddenInfo) delete fHiddenInfo; // cout << "Deleted track " << this << endl; @@ -253,6 +267,7 @@ void AliFemtoTrack::SetTPCSharedMap(const TBits& aBits) void AliFemtoTrack::SetKinkIndexes(int points[3]) { + // Transfer the Kink indices fKinkIndexes[0] = points[0]; fKinkIndexes[1] = points[1]; fKinkIndexes[2] = points[2]; @@ -260,8 +275,59 @@ void AliFemtoTrack::SetKinkIndexes(int points[3]) int AliFemtoTrack::KinkIndex(int aIndex) const { + // Return Kink index if ((aIndex <3) && (aIndex>=0)) return fKinkIndexes[aIndex]; else return 0; } + +// void AliFemtoTrack::SetXTPC(const AliFemtoThreeVector& aXTPC) +// { +// fXTPC = aXTPC; +// } + +// void AliFemtoTrack::SetXTPC(double *aXTPC) +// { +// fXTPC.setX(aXTPC[0]); +// fXTPC.setY(aXTPC[1]); +// fXTPC.setZ(aXTPC[2]); +// } + +// AliFemtoThreeVector AliFemtoTrack::XTPC() const +// { +// return fXTPC; +// } + +const AliFemtoThreeVector& AliFemtoTrack::NominalTpcExitPoint() const +{ + return fNominalTpcExitPoint; +} +const AliFemtoThreeVector& AliFemtoTrack::NominalTpcEntrancePoint() const +{ + return fNominalTpcEntrancePoint; +} + +void AliFemtoTrack::SetNominalTPCEntrancePoint(const AliFemtoThreeVector& aXTPC) +{ + fNominalTpcEntrancePoint = aXTPC; +} +void AliFemtoTrack::SetNominalTPCEntrancePoint(double *aXTPC) +{ + // Store the nominal TPC entrance point + fNominalTpcEntrancePoint.setX(aXTPC[0]); + fNominalTpcEntrancePoint.setY(aXTPC[1]); + fNominalTpcEntrancePoint.setZ(aXTPC[2]); +} + +void AliFemtoTrack::SetNominalTPCExitPoint(const AliFemtoThreeVector& aXTPC) +{ + fNominalTpcExitPoint = aXTPC; +} +void AliFemtoTrack::SetNominalTPCExitPoint(double *aXTPC) +{ + // Store the nominal TPC exit point + fNominalTpcExitPoint.setX(aXTPC[0]); + fNominalTpcExitPoint.setY(aXTPC[1]); + fNominalTpcExitPoint.setZ(aXTPC[2]); +} diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoTrack.h b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoTrack.h index 744e724c221..60dad0c603c 100644 --- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoTrack.h +++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoTrack.h @@ -78,9 +78,9 @@ public: void SetPidProbProton(const float& x); void SetPidProbMuon(const float& x); - void SetP(const AliFemtoThreeVector&); + void SetP(const AliFemtoThreeVector& p); void SetPt(const float& x); - void SetHelix(const AliFmPhysicalHelixD&); + void SetHelix(const AliFmPhysicalHelixD& h); void SetTrackId(const short& s); void SetFlags(const long int& i); void SetLabel(const int& i); @@ -114,6 +114,17 @@ public: AliFemtoHiddenInfo* GetHiddenInfo() const; /***/ + const AliFemtoThreeVector& NominalTpcExitPoint() const; + const AliFemtoThreeVector& NominalTpcEntrancePoint() const; + + void SetNominalTPCEntrancePoint(const AliFemtoThreeVector& aXTPC); + void SetNominalTPCEntrancePoint(double *aXTPC); + + void SetNominalTPCExitPoint(const AliFemtoThreeVector& aXTPC); + void SetNominalTPCExitPoint(double *aXTPC); + void SetSigmaToVertex(const float& Sigma); + float SigmaToVertex() const; + //Alice stuff enum { kITSin=0x0001,kITSout=0x0002,kITSrefit=0x0004,kITSpid=0x0008, @@ -140,7 +151,6 @@ public: AliFemtoThreeVector fP; // track momentum float fPt; // transverse momenta AliFmPhysicalHelixD fHelix; // track helix - //alice stuff long int fFlags; //Reconsruction status flags int fLabel; //Track label @@ -156,8 +166,11 @@ public: short fTPCnclsF; // number of findable clusters in the TPC short fTPCsignalN; // number of points used for dEdx float fTPCsignalS; // RMS of dEdx measurement + float fSigmaToVertex; // Distance from track to vertex in sigmas TBits fClusters; // Cluster per padrow map TBits fShared; // Sharing per padrow map + AliFemtoThreeVector fNominalTpcEntrancePoint; // Nominal track entrance point into TPC + AliFemtoThreeVector fNominalTpcExitPoint; // Nominal track exit point from TPC int fKinkIndexes[3]; // Kink Index list /* Th stuff */ diff --git a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoChi2CorrFctn.cxx b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoChi2CorrFctn.cxx new file mode 100644 index 00000000000..5db10fffa74 --- /dev/null +++ b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoChi2CorrFctn.cxx @@ -0,0 +1,332 @@ +//////////////////////////////////////////////////////////////////////////////// +/// /// +/// AliFemtoChi2CorrFctn - A correlation function that saves the correlation /// +/// function as a function of single track quality (chi2/ndof) for its and /// +/// tpc /// +/// Authors: Adam Kisiel kisiel@mps.ohio-state.edu /// +/// /// +//////////////////////////////////////////////////////////////////////////////// + +#include "AliFemtoChi2CorrFctn.h" +//#include "AliFemtoHisto.hh" +#include + +#ifdef __ROOT__ +ClassImp(AliFemtoChi2CorrFctn) +#endif + +//____________________________ +AliFemtoChi2CorrFctn::AliFemtoChi2CorrFctn(char* title, const int& nbins, const float& QinvLo, const float& QinvHi): + fChi2ITSSUMNumerator(0), + fChi2ITSSUMDenominator(0), + fChi2TPCSUMNumerator(0), + fChi2TPCSUMDenominator(0), + fChi2ITSONENumerator(0), + fChi2ITSONEDenominator(0), + fChi2TPCONENumerator(0), + fChi2TPCONEDenominator(0), + fSigmaToVertexNumerator(0), + fSigmaToVertexDenominator(0) +{ + // set up numerator + char tTitNum[100] = "NumChi2ITSSUM"; + strcat(tTitNum,title); + fChi2ITSSUMNumerator = new TH2D(tTitNum,title,nbins,QinvLo,QinvHi,200,0.0,6.0); + // set up denominator + char tTitDen[100] = "DenChi2ITSSUM"; + strcat(tTitDen,title); + fChi2ITSSUMDenominator = new TH2D(tTitDen,title,nbins,QinvLo,QinvHi,200,0.0,6.0); + + // set up numerator + char tTit2Num[100] = "NumChi2TPCSUM"; + strcat(tTit2Num,title); + fChi2TPCSUMNumerator = new TH2D(tTit2Num,title,nbins,QinvLo,QinvHi,200,0.0,6.0); + // set up denominator + char tTit2Den[100] = "DenChi2TPCSUM"; + strcat(tTit2Den,title); + fChi2TPCSUMDenominator = new TH2D(tTit2Den,title,nbins,QinvLo,QinvHi,200,0.0,6.0); + + // to enable error bar calculation... + fChi2ITSSUMNumerator->Sumw2(); + fChi2ITSSUMDenominator->Sumw2(); + + fChi2TPCSUMNumerator->Sumw2(); + fChi2TPCSUMDenominator->Sumw2(); + // set up numerator + sprintf(tTitNum,"%s%s","NumChi2ITSONE",title); + fChi2ITSONENumerator = new TH2D(tTitNum,title,nbins,QinvLo,QinvHi,200,0.0,6.0); + // set up denominator + sprintf(tTitDen,"%s%s", "DenChi2ITSONE", title); + fChi2ITSONEDenominator = new TH2D(tTitDen,title,nbins,QinvLo,QinvHi,200,0.0,6.0); + + // set up numerator + sprintf(tTit2Num,"%s%s","NumChi2TPCONE",title); + fChi2TPCONENumerator = new TH2D(tTit2Num,title,nbins,QinvLo,QinvHi,200,0.0,6.0); + // set up denominator + sprintf(tTit2Den,"%s%s", "DenChi2TPCONE", title); + fChi2TPCONEDenominator = new TH2D(tTit2Den,title,nbins,QinvLo,QinvHi,200,0.0,6.0); + + // set up numerator + sprintf(tTit2Num,"%s%s","NumSigmaToVertex",title); + fSigmaToVertexNumerator = new TH2D(tTit2Num,title,nbins,QinvLo,QinvHi,200,0.0,6.0); + // set up denominator + sprintf(tTit2Den,"%s%s", "DenSigmaToVertex", title); + fSigmaToVertexDenominator = new TH2D(tTit2Den,title,nbins,QinvLo,QinvHi,200,0.0,6.0); + + // to enable error bar calculation... + fChi2ITSONENumerator->Sumw2(); + fChi2ITSONEDenominator->Sumw2(); + + fChi2TPCONENumerator->Sumw2(); + fChi2TPCONEDenominator->Sumw2(); +} + +//____________________________ +AliFemtoChi2CorrFctn::AliFemtoChi2CorrFctn(const AliFemtoChi2CorrFctn& aCorrFctn) : + fChi2ITSSUMNumerator(0), + fChi2ITSSUMDenominator(0), + fChi2TPCSUMNumerator(0), + fChi2TPCSUMDenominator(0), + fChi2ITSONENumerator(0), + fChi2ITSONEDenominator(0), + fChi2TPCONENumerator(0), + fChi2TPCONEDenominator(0), + fSigmaToVertexNumerator(0), + fSigmaToVertexDenominator(0) +{ + // copy constructor + if (aCorrFctn.fChi2ITSSUMNumerator) + fChi2ITSSUMNumerator = new TH2D(*aCorrFctn.fChi2ITSSUMNumerator); + if (aCorrFctn.fChi2ITSSUMDenominator) + fChi2ITSSUMDenominator = new TH2D(*aCorrFctn.fChi2ITSSUMDenominator); + if (aCorrFctn.fChi2TPCSUMNumerator) + fChi2TPCSUMNumerator = new TH2D(*aCorrFctn.fChi2TPCSUMNumerator); + if (aCorrFctn.fChi2TPCSUMDenominator) + fChi2TPCSUMDenominator = new TH2D(*aCorrFctn.fChi2TPCSUMDenominator); + if (aCorrFctn.fChi2ITSONENumerator) + fChi2ITSONENumerator = new TH2D(*aCorrFctn.fChi2ITSONENumerator); + if (aCorrFctn.fChi2ITSONEDenominator) + fChi2ITSONEDenominator = new TH2D(*aCorrFctn.fChi2ITSONEDenominator); + if (aCorrFctn.fChi2TPCONENumerator) + fChi2TPCONENumerator = new TH2D(*aCorrFctn.fChi2TPCONENumerator); + if (aCorrFctn.fChi2TPCONEDenominator) + fChi2TPCONEDenominator = new TH2D(*aCorrFctn.fChi2TPCONEDenominator); + if (aCorrFctn.fSigmaToVertexNumerator) + fSigmaToVertexNumerator = new TH2D(*aCorrFctn.fSigmaToVertexNumerator); + if (aCorrFctn.fSigmaToVertexDenominator) + fSigmaToVertexDenominator = new TH2D(*aCorrFctn.fSigmaToVertexDenominator); +} +//____________________________ +AliFemtoChi2CorrFctn::~AliFemtoChi2CorrFctn(){ + // destructor + delete fChi2ITSSUMNumerator; + delete fChi2ITSSUMDenominator; + delete fChi2TPCSUMNumerator; + delete fChi2TPCSUMDenominator; + delete fChi2ITSONENumerator; + delete fChi2ITSONEDenominator; + delete fChi2TPCONENumerator; + delete fChi2TPCONEDenominator; + delete fSigmaToVertexNumerator; + delete fSigmaToVertexDenominator; +} +//_________________________ +AliFemtoChi2CorrFctn& AliFemtoChi2CorrFctn::operator=(const AliFemtoChi2CorrFctn& aCorrFctn) +{ + // assignment operator + if (this == &aCorrFctn) + return *this; + + if (aCorrFctn.fChi2ITSSUMNumerator) + fChi2ITSSUMNumerator = new TH2D(*aCorrFctn.fChi2ITSSUMNumerator); + else + fChi2ITSSUMNumerator = 0; + if (aCorrFctn.fChi2ITSSUMDenominator) + fChi2ITSSUMDenominator = new TH2D(*aCorrFctn.fChi2ITSSUMDenominator); + else + fChi2ITSSUMDenominator = 0; + if (aCorrFctn.fChi2TPCSUMNumerator) + fChi2TPCSUMNumerator = new TH2D(*aCorrFctn.fChi2TPCSUMNumerator); + else + fChi2TPCSUMNumerator = 0; + if (aCorrFctn.fChi2TPCSUMDenominator) + fChi2TPCSUMDenominator = new TH2D(*aCorrFctn.fChi2TPCSUMDenominator); + else + fChi2TPCSUMDenominator = 0; + if (aCorrFctn.fChi2ITSONENumerator) + fChi2ITSONENumerator = new TH2D(*aCorrFctn.fChi2ITSONENumerator); + else + fChi2ITSONENumerator = 0; + if (aCorrFctn.fChi2ITSONEDenominator) + fChi2ITSONEDenominator = new TH2D(*aCorrFctn.fChi2ITSONEDenominator); + else + fChi2ITSONEDenominator = 0; + if (aCorrFctn.fChi2TPCONENumerator) + fChi2TPCONENumerator = new TH2D(*aCorrFctn.fChi2TPCONENumerator); + else + fChi2TPCONENumerator = 0; + if (aCorrFctn.fChi2TPCONEDenominator) + fChi2TPCONEDenominator = new TH2D(*aCorrFctn.fChi2TPCONEDenominator); + else + fChi2TPCONEDenominator = 0; + if (aCorrFctn.fSigmaToVertexNumerator) + fSigmaToVertexNumerator = new TH2D(*aCorrFctn.fSigmaToVertexNumerator); + else + fSigmaToVertexNumerator = 0; + if (aCorrFctn.fSigmaToVertexDenominator) + fSigmaToVertexDenominator = new TH2D(*aCorrFctn.fSigmaToVertexDenominator); + else + fSigmaToVertexDenominator = 0; + + return *this; +} +//_________________________ +void AliFemtoChi2CorrFctn::Finish(){ + // here is where we should normalize, fit, etc... + // we should NOT Draw() the histos (as I had done it below), + // since we want to insulate ourselves from root at this level + // of the code. Do it instead at root command line with browser. + // mShareNumerator->Draw(); + //mShareDenominator->Draw(); + //mRatio->Draw(); + +} + +//____________________________ +AliFemtoString AliFemtoChi2CorrFctn::Report(){ + // create report + string stemp = "ITS and TPC quality Correlation Function Report:\n"; + char ctemp[100]; + sprintf(ctemp,"Number of entries in numerator:\t%E\n",fChi2ITSSUMNumerator->GetEntries()); + stemp += ctemp; + sprintf(ctemp,"Number of entries in denominator:\t%E\n",fChi2ITSSUMDenominator->GetEntries()); + stemp += ctemp; + // stemp += mCoulombWeight->Report(); + AliFemtoString returnThis = stemp; + return returnThis; +} +//____________________________ +void AliFemtoChi2CorrFctn::AddRealPair( AliFemtoPair* pair){ + // add real (effect) pair + double tQinv = fabs(pair->QInv()); // note - qInv() will be negative for identical pairs... + + fChi2ITSSUMNumerator->Fill(tQinv, + (pair->Track1()->Track()->ITSchi2() + + pair->Track2()->Track()->ITSchi2())/ + (pair->Track1()->Track()->ITSncls() + + pair->Track2()->Track()->ITSncls())); + fChi2TPCSUMNumerator->Fill(tQinv, + (pair->Track1()->Track()->TPCchi2() + + pair->Track2()->Track()->TPCchi2())/ + (pair->Track1()->Track()->TPCncls() + + pair->Track2()->Track()->TPCncls())); + if ((pair->Track1()->Track()->ITSchi2()/pair->Track1()->Track()->ITSncls()) > (pair->Track2()->Track()->ITSchi2()/pair->Track2()->Track()->ITSncls())) { + fChi2ITSONENumerator->Fill(tQinv, + (pair->Track1()->Track()->ITSchi2()/ + pair->Track1()->Track()->ITSncls())); + } + else { + fChi2ITSONENumerator->Fill(tQinv, + (pair->Track2()->Track()->ITSchi2()/ + pair->Track2()->Track()->ITSncls())); + } + if ((pair->Track1()->Track()->TPCchi2()/pair->Track1()->Track()->TPCncls()) > (pair->Track2()->Track()->TPCchi2()/pair->Track2()->Track()->TPCncls())) { + fChi2TPCONENumerator->Fill(tQinv, + (pair->Track1()->Track()->TPCchi2()/ + pair->Track1()->Track()->TPCncls())); + } + else { + fChi2TPCONENumerator->Fill(tQinv, + (pair->Track2()->Track()->TPCchi2()/ + pair->Track2()->Track()->TPCncls())); + } + if (pair->Track1()->Track()->SigmaToVertex() > pair->Track2()->Track()->SigmaToVertex()) { + fSigmaToVertexNumerator->Fill(tQinv, + pair->Track1()->Track()->SigmaToVertex()); + } + else { + fSigmaToVertexNumerator->Fill(tQinv, + pair->Track2()->Track()->SigmaToVertex()); + } +} +//____________________________ +void AliFemtoChi2CorrFctn::AddMixedPair( AliFemtoPair* pair){ + // add mixed (background) pair + double tQinv = fabs(pair->QInv()); // note - qInv() will be negative for identical pairs... + + fChi2ITSSUMDenominator->Fill(tQinv, + (pair->Track1()->Track()->ITSchi2() + + pair->Track2()->Track()->ITSchi2())/ + (pair->Track1()->Track()->ITSncls() + + pair->Track2()->Track()->ITSncls())); + fChi2TPCSUMDenominator->Fill(tQinv, + (pair->Track1()->Track()->TPCchi2() + + pair->Track2()->Track()->TPCchi2())/ + (pair->Track1()->Track()->TPCncls() + + pair->Track2()->Track()->TPCncls())); + if ((pair->Track1()->Track()->ITSchi2()/pair->Track1()->Track()->ITSncls()) > (pair->Track2()->Track()->ITSchi2()/pair->Track2()->Track()->ITSncls())) { + fChi2ITSONEDenominator->Fill(tQinv, + (pair->Track1()->Track()->ITSchi2()/ + pair->Track1()->Track()->ITSncls())); + } + else { + fChi2ITSONEDenominator->Fill(tQinv, + (pair->Track2()->Track()->ITSchi2()/ + pair->Track2()->Track()->ITSncls())); + } + if ((pair->Track1()->Track()->TPCchi2()/pair->Track1()->Track()->TPCncls()) > (pair->Track2()->Track()->TPCchi2()/pair->Track2()->Track()->TPCncls())) { + fChi2TPCONEDenominator->Fill(tQinv, + (pair->Track1()->Track()->TPCchi2()/ + pair->Track1()->Track()->TPCncls())); + } + else { + fChi2TPCONEDenominator->Fill(tQinv, + (pair->Track2()->Track()->TPCchi2()/ + pair->Track2()->Track()->TPCncls())); + } + if (pair->Track1()->Track()->SigmaToVertex() > pair->Track2()->Track()->SigmaToVertex()) { + fSigmaToVertexDenominator->Fill(tQinv, + pair->Track1()->Track()->SigmaToVertex()); + } + else { + fSigmaToVertexDenominator->Fill(tQinv, + pair->Track2()->Track()->SigmaToVertex()); + } +} + + +void AliFemtoChi2CorrFctn::WriteHistos() +{ + // Write out result histograms + fChi2ITSSUMNumerator->Write(); + fChi2ITSSUMDenominator->Write(); + fChi2TPCSUMNumerator->Write(); + fChi2TPCSUMDenominator->Write(); + fChi2ITSONENumerator->Write(); + fChi2ITSONEDenominator->Write(); + fChi2TPCONENumerator->Write(); + fChi2TPCONEDenominator->Write(); + fSigmaToVertexNumerator->Write(); + fSigmaToVertexDenominator->Write(); + +} + +TList* AliFemtoChi2CorrFctn::GetOutputList() +{ + // Prepare the list of objects to be written to the output + TList *tOutputList = new TList(); + + tOutputList->Add(fChi2ITSSUMNumerator); + tOutputList->Add(fChi2ITSSUMDenominator); + tOutputList->Add(fChi2TPCSUMNumerator); + tOutputList->Add(fChi2TPCSUMDenominator); + tOutputList->Add(fChi2ITSONENumerator); + tOutputList->Add(fChi2ITSONEDenominator); + tOutputList->Add(fChi2TPCONENumerator); + tOutputList->Add(fChi2TPCONEDenominator); + tOutputList->Add(fSigmaToVertexNumerator); + tOutputList->Add(fSigmaToVertexDenominator); + + return tOutputList; + +} diff --git a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoChi2CorrFctn.h b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoChi2CorrFctn.h new file mode 100644 index 00000000000..f38032b329c --- /dev/null +++ b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoChi2CorrFctn.h @@ -0,0 +1,57 @@ +//////////////////////////////////////////////////////////////////////////////// +/// /// +/// AliFemtoChi2CorrFctn - A correlation function that saves the correlation /// +/// function as a function of single track quality (chi2/ndof) for its and /// +/// tpc /// +/// Authors: Adam Kisiel kisiel@mps.ohio-state.edu /// +/// /// +//////////////////////////////////////////////////////////////////////////////// + +#ifndef ALIFEMTOCHI2CORRFCTN_H +#define ALIFEMTOCHI2CORRFCTN_H + +#include "TH1D.h" +#include "TH2D.h" +#include "AliFemtoCorrFctn.h" + +class AliFemtoChi2CorrFctn : public AliFemtoCorrFctn { +public: + AliFemtoChi2CorrFctn(char* title, const int& nbins, const float& QinvLo, const float& QinvHi); + AliFemtoChi2CorrFctn(const AliFemtoChi2CorrFctn& aCorrFctn); + virtual ~AliFemtoChi2CorrFctn(); + + AliFemtoChi2CorrFctn& operator=(const AliFemtoChi2CorrFctn& aCorrFctn); + + virtual AliFemtoString Report(); + virtual void AddRealPair(AliFemtoPair* aPair); + virtual void AddMixedPair(AliFemtoPair* aPair); + + virtual void Finish(); + + void WriteHistos(); + virtual TList* GetOutputList(); +private: + + TH2D *fChi2ITSSUMNumerator; // Numerator as a function of ITS quality sum for the pair + TH2D *fChi2ITSSUMDenominator; // Denominator as a function of ITS quality sum for the pair + + TH2D *fChi2TPCSUMNumerator; // Numerator as a function of TPC quality sum for the pair + TH2D *fChi2TPCSUMDenominator; // Denominator as a function of TPC quality sum for the pair + + TH2D *fChi2ITSONENumerator; // Numerator as a function of ITS quality for the worse track + TH2D *fChi2ITSONEDenominator; // Denominator as a function of ITS quality for the worse track + + TH2D *fChi2TPCONENumerator; // Numerator as a function of TPC quality for the worse track + TH2D *fChi2TPCONEDenominator; // Denominator as a function of TPC quality for the worse track + + TH2D *fSigmaToVertexNumerator; // Numerator as a function of sigma to vertex + TH2D *fSigmaToVertexDenominator; // Numerator as a function of sigma to vertex + +#ifdef __ROOT__ + ClassDef(AliFemtoChi2CorrFctn, 1) +#endif +}; + + +#endif + diff --git a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoCutMonitorParticleMomRes.cxx b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoCutMonitorParticleMomRes.cxx new file mode 100644 index 00000000000..3051b44e2f4 --- /dev/null +++ b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoCutMonitorParticleMomRes.cxx @@ -0,0 +1,178 @@ +//////////////////////////////////////////////////////////////////////////////// +// // +// AliFemtoCutMonitorParticleMomRes - the cut monitor for particles to study // +// the difference between reconstructed and true momentum // +// // +//////////////////////////////////////////////////////////////////////////////// +#include "AliFemtoCutMonitorParticleMomRes.h" +#include +#include +#include +#include +#include "AliFemtoModelHiddenInfo.h" + +AliFemtoCutMonitorParticleMomRes::AliFemtoCutMonitorParticleMomRes(): + fMomRes3D(0), + fMomResXvsP(0), + fMomResYvsP(0), + fMomResZvsP(0), + fImpactXY(0), + fImpactZ(0), + fSigma(0), + fMass(0.13957) +{ + // Default constructor + fMomRes3D = new TH3D("MomRes3D", "Momentum resolution", 100, -0.05, 0.05, 100, -0.05, 0.05, 100, -0.05, 0.05); + fMomResXvsP = new TH2D("MomResXvsP", "X momentum resolution vs P", 100, 0.1, 2.0, 100, -0.05, 0.05); + fMomResYvsP = new TH2D("MomResYvsP", "Y momentum resolution vs P", 100, 0.1, 2.0, 100, -0.05, 0.05); + fMomResZvsP = new TH2D("MomResZvsP", "Z momentum resolution vs P", 100, 0.1, 2.0, 100, -0.05, 0.05); + fImpactXY = new TH2D("ImpactXY", "XY impact parameter vs P", 100, 0.1, 2.0, 200, -1.0, 1.0); + fImpactZ = new TH2D("ImpactZ", "Z impact parameter vs P" , 100, 0.1, 2.0, 200, -1.0, 1.0); + fSigma = new TH2D("Sigma", "Sigma to vertex vs P" , 100, 0.1, 2.0, 200, -5.0, 5.0); +} + +AliFemtoCutMonitorParticleMomRes::AliFemtoCutMonitorParticleMomRes(const char *aName, float aMass): + fMomRes3D(0), + fMomResXvsP(0), + fMomResYvsP(0), + fMomResZvsP(0), + fImpactXY(0), + fImpactZ(0), + fSigma(0), + fMass(aMass) +{ + // Normal constructor + char name[200]; + snprintf(name, 200, "MomRes3D%s", aName); + fMomRes3D = new TH3D(name, "Momentum resolution", 100, -0.05, 0.05, 100, -0.05, 0.05, 100, -0.05, 0.05); + snprintf(name, 200, "MomResXvsP%s", aName); + fMomResXvsP = new TH2D(name, "X momentum resolution vs P", 100, 0.1, 2.0, 100, -0.05, 0.05); + snprintf(name, 200, "MomResYvsP%s", aName); + fMomResYvsP = new TH2D(name, "Y momentum resolution vs P", 100, 0.1, 2.0, 100, -0.05, 0.05); + snprintf(name, 200, "MomResZvsP%s", aName); + fMomResZvsP = new TH2D(name, "Z momentum resolution vs P", 100, 0.1, 2.0, 100, -0.05, 0.05); + snprintf(name, 200, "ImpactXY%s", aName); + fImpactXY = new TH2D(name, "XY impact parameter vs P", 100, 0.1, 2.0, 200, -1.0, 1.0); + snprintf(name, 200, "ImpactZ%s", aName); + fImpactZ = new TH2D(name, "Z impact parameter vs P" , 100, 0.1, 2.0, 200, -1.0, 1.0); + snprintf(name, 200, "Sigma%s", aName); + fSigma = new TH2D(name, "Z impact parameter vs P" , 100, 0.1, 2.0, 200, -5.0, 5.0); +} + +AliFemtoCutMonitorParticleMomRes::AliFemtoCutMonitorParticleMomRes(const AliFemtoCutMonitorParticleMomRes &aCut): + fMomRes3D(0), + fMomResXvsP(0), + fMomResYvsP(0), + fMomResZvsP(0), + fImpactXY(0), + fImpactZ(0), + fSigma(0), + fMass(0.13957) +{ + // copy constructor + if (fMomRes3D) delete fMomRes3D; + fMomRes3D = new TH3D(*aCut.fMomRes3D); + if (fMomResXvsP) delete fMomResXvsP; + fMomResXvsP = new TH2D(*aCut.fMomResXvsP); + if (fMomResYvsP) delete fMomResYvsP; + fMomResYvsP = new TH2D(*aCut.fMomResYvsP); + if (fMomResZvsP) delete fMomResZvsP; + fMomResZvsP = new TH2D(*aCut.fMomResZvsP); + if (fImpactXY) delete fImpactXY; + fImpactXY = new TH2D(*aCut.fImpactXY); + if (fImpactZ) delete fImpactZ; + fImpactZ = new TH2D(*aCut.fImpactZ); + if (fSigma) delete fSigma; + fSigma = new TH2D(*aCut.fSigma); + fMass = aCut.fMass; +} + +AliFemtoCutMonitorParticleMomRes::~AliFemtoCutMonitorParticleMomRes() +{ + // Destructor + delete fMomRes3D; + delete fMomResXvsP; + delete fMomResYvsP; + delete fMomResZvsP; + delete fImpactXY; + delete fImpactZ; + delete fSigma; +} + +AliFemtoCutMonitorParticleMomRes& AliFemtoCutMonitorParticleMomRes::operator=(const AliFemtoCutMonitorParticleMomRes& aCut) +{ + // assignment operator + if (this == &aCut) + return *this; + + if (fMomRes3D) delete fMomRes3D; + fMomRes3D = new TH3D(*aCut.fMomRes3D); + if (fMomResXvsP) delete fMomResXvsP; + fMomResXvsP = new TH2D(*aCut.fMomResXvsP); + if (fMomResYvsP) delete fMomResYvsP; + fMomResYvsP = new TH2D(*aCut.fMomResYvsP); + if (fMomResZvsP) delete fMomResZvsP; + fMomResZvsP = new TH2D(*aCut.fMomResZvsP); + if (fImpactXY) delete fImpactXY; + fImpactXY = new TH2D(*aCut.fImpactXY); + if (fImpactZ) delete fImpactZ; + fImpactZ = new TH2D(*aCut.fImpactZ); + if (fSigma) delete fSigma; + fSigma = new TH2D(*aCut.fSigma); + + return *this; +} + +AliFemtoString AliFemtoCutMonitorParticleMomRes::Report(){ + // Prepare report from the execution + string stemp = "*** AliFemtoCutMonitorParticleMomRes report"; + AliFemtoString returnThis = stemp; + return returnThis; +} + +void AliFemtoCutMonitorParticleMomRes::Fill(const AliFemtoTrack* aTrack) +{ + AliFemtoModelHiddenInfo *tInf = ( AliFemtoModelHiddenInfo *) aTrack->GetHiddenInfo(); + fMomRes3D->Fill(tInf->GetTrueMomentum()->x() - aTrack->P().x(), + tInf->GetTrueMomentum()->y() - aTrack->P().y(), + tInf->GetTrueMomentum()->z() - aTrack->P().z()); + + fMomResXvsP->Fill(aTrack->P().mag(), + tInf->GetTrueMomentum()->x() - aTrack->P().x()); + fMomResYvsP->Fill(aTrack->P().mag(), + tInf->GetTrueMomentum()->y() - aTrack->P().y()); + fMomResZvsP->Fill(aTrack->P().mag(), + tInf->GetTrueMomentum()->z() - aTrack->P().z()); + fImpactXY->Fill(aTrack->P().mag(), + aTrack->ImpactD()); + fImpactZ->Fill(aTrack->P().mag(), + aTrack->ImpactZ()); + fSigma->Fill(aTrack->P().mag(), + aTrack->SigmaToVertex()); +} + +void AliFemtoCutMonitorParticleMomRes::Write() +{ + // Write out the relevant histograms + fMomRes3D->Write(); + fMomResXvsP->Write(); + fMomResYvsP->Write(); + fMomResZvsP->Write(); + fImpactXY->Write(); + fImpactZ->Write(); + fSigma->Write(); +} + +TList *AliFemtoCutMonitorParticleMomRes::GetOutputList() +{ + TList *tOutputList = new TList(); + tOutputList->Add(fMomRes3D); + tOutputList->Add(fMomResXvsP); + tOutputList->Add(fMomResYvsP); + tOutputList->Add(fMomResZvsP); + tOutputList->Add(fImpactXY); + tOutputList->Add(fImpactZ); + tOutputList->Add(fSigma); + + return tOutputList; +} diff --git a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoCutMonitorParticleMomRes.h b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoCutMonitorParticleMomRes.h new file mode 100644 index 00000000000..0d3bb55e818 --- /dev/null +++ b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoCutMonitorParticleMomRes.h @@ -0,0 +1,50 @@ +//////////////////////////////////////////////////////////////////////////////// +/// /// +/// AliFemtoCutMonitorParticleMomRes - the cut monitor for particles to study /// +/// the difference between reconstructed and true momentum /// +/// /// +//////////////////////////////////////////////////////////////////////////////// +#ifndef AliFemtoCutMonitorParticleMomRes_hh +#define AliFemtoCutMonitorParticleMomRes_hh + +class AliFemtoEvent; +class AliFemtoTrack; +class AliFemtoV0; +class AliFemtoKink; +class AliFemtoPair; // Gael 12/04/02 +class TH1D; +class TH2D; +class TH3D; +class TList; +#include "AliFemtoString.h" +#include "AliFemtoParticleCollection.h" +#include "AliFemtoCutMonitor.h" + +class AliFemtoCutMonitorParticleMomRes : public AliFemtoCutMonitor{ + +public: + AliFemtoCutMonitorParticleMomRes(); + AliFemtoCutMonitorParticleMomRes(const char *aName, float aMass); + AliFemtoCutMonitorParticleMomRes(const AliFemtoCutMonitorParticleMomRes &aCut); + virtual ~AliFemtoCutMonitorParticleMomRes(); + + AliFemtoCutMonitorParticleMomRes& operator=(const AliFemtoCutMonitorParticleMomRes& aCut); + + virtual AliFemtoString Report(); + virtual void Fill(const AliFemtoTrack* aTrack); + void Write(); + + virtual TList *GetOutputList(); + +private: + TH3D *fMomRes3D; // 3D momentum resolution + TH2D *fMomResXvsP; // X resolution vs momentum + TH2D *fMomResYvsP; // Y resolution vs momentum + TH2D *fMomResZvsP; // Z resolution vs momentum + TH2D *fImpactXY; // XY impact parameter + TH2D *fImpactZ; // Z impact parameter + TH2D *fSigma; // Sigma to vertex vs momentum + float fMass; // Mass hypothesis +}; + +#endif diff --git a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoCutMonitorParticleYPt.cxx b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoCutMonitorParticleYPt.cxx new file mode 100644 index 00000000000..ee1954163d3 --- /dev/null +++ b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoCutMonitorParticleYPt.cxx @@ -0,0 +1,79 @@ +//////////////////////////////////////////////////////////////////////////////// +// // +// AliFemtoCutMonitorParticleYPt - the cut monitor for particles to study // +// the difference between reconstructed and true momentum // +// // +//////////////////////////////////////////////////////////////////////////////// +#include +#include +#include "AliFemtoCutMonitorParticleYPt.h" +#include "AliFemtoModelHiddenInfo.h" + +AliFemtoCutMonitorParticleYPt::AliFemtoCutMonitorParticleYPt(): + fYPt(0), + fMass(0.13957) +{ + // Default constructor + fYPt = new TH2D("YPt", "Rapidity vs Pt", 100, -1.0, 1.0, 100, 0.1, 2.0); +} + +AliFemtoCutMonitorParticleYPt::AliFemtoCutMonitorParticleYPt(const char *aName, float aMass): + fYPt(0), + fMass(aMass) +{ + // Normal constructor + char name[200]; + snprintf(name, 200, "YPt%s", aName); + fYPt = new TH2D(name, "Rapdity vs Pt", 100, -1.0, 1.0, 100, 0.1, 2.0); +} + +AliFemtoCutMonitorParticleYPt::AliFemtoCutMonitorParticleYPt(const AliFemtoCutMonitorParticleYPt &aCut): + fYPt(0), + fMass(0.13957) +{ + // copy constructor + if (fYPt) delete fYPt; + fYPt = new TH2D(*aCut.fYPt); + fMass = aCut.fMass; +} + +AliFemtoCutMonitorParticleYPt::~AliFemtoCutMonitorParticleYPt() +{ + // Destructor + delete fYPt; +} + +AliFemtoCutMonitorParticleYPt& AliFemtoCutMonitorParticleYPt::operator=(const AliFemtoCutMonitorParticleYPt& aCut) +{ + // assignment operator + if (this == &aCut) + return *this; + + if (fYPt) delete fYPt; + fYPt = new TH2D(*aCut.fYPt); + + return *this; +} + +AliFemtoString AliFemtoCutMonitorParticleYPt::Report(){ + // Prepare report from the execution + string stemp = "*** AliFemtoCutMonitorParticleYPt report"; + AliFemtoString returnThis = stemp; + return returnThis; +} + +void AliFemtoCutMonitorParticleYPt::Fill(const AliFemtoTrack* aTrack) +{ + // Fill in the monitor histograms with the values from the current track + float tEnergy = ::sqrt(aTrack->P().mag2()+fMass*fMass); + float tRapidity = 0.5*::log((tEnergy+aTrack->P().z())/(tEnergy-aTrack->P().z())); + float tPt = ::sqrt((aTrack->P().x())*(aTrack->P().x())+(aTrack->P().y())*(aTrack->P().y())); + fYPt->Fill(tRapidity, tPt); +} + +void AliFemtoCutMonitorParticleYPt::Write() +{ + // Write out the relevant histograms + fYPt->Write(); +} + diff --git a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoCutMonitorParticleYPt.h b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoCutMonitorParticleYPt.h new file mode 100644 index 00000000000..2c11d9fa63d --- /dev/null +++ b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoCutMonitorParticleYPt.h @@ -0,0 +1,40 @@ +//////////////////////////////////////////////////////////////////////////////// +/// /// +/// AliFemtoCutMonitorParticleYPt - the cut monitor for particles to study /// +/// the difference between reconstructed and true momentum /// +/// /// +//////////////////////////////////////////////////////////////////////////////// +#ifndef AliFemtoCutMonitorParticleYPt_hh +#define AliFemtoCutMonitorParticleYPt_hh + +class AliFemtoEvent; +class AliFemtoTrack; +class AliFemtoV0; +class AliFemtoKink; +class AliFemtoPair; // Gael 12/04/02 +class TH1D; +class TH2D; +#include "AliFemtoString.h" +#include "AliFemtoParticleCollection.h" +#include "AliFemtoCutMonitor.h" + +class AliFemtoCutMonitorParticleYPt : public AliFemtoCutMonitor{ + +public: + AliFemtoCutMonitorParticleYPt(); + AliFemtoCutMonitorParticleYPt(const char *aName, float aMass); + AliFemtoCutMonitorParticleYPt(const AliFemtoCutMonitorParticleYPt &aCut); + virtual ~AliFemtoCutMonitorParticleYPt(); + + AliFemtoCutMonitorParticleYPt& operator=(const AliFemtoCutMonitorParticleYPt& aCut); + + virtual AliFemtoString Report(); + virtual void Fill(const AliFemtoTrack* aTrack); + void Write(); + +private: + TH2D *fYPt; // Rapidity vs. Pt monitor + float fMass; // Mass hypothesis +}; + +#endif diff --git a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoESDTrackCut.cxx b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoESDTrackCut.cxx index 741f0083b62..5b146be8b54 100644 --- a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoESDTrackCut.cxx +++ b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoESDTrackCut.cxx @@ -88,6 +88,9 @@ AliFemtoESDTrackCut::AliFemtoESDTrackCut() : fStatus(0), fminTPCclsF(0), fminITScls(0), + fMaxITSchiNdof(1000.0), + fMaxTPCchiNdof(1000.0), + fMaxSigmaToVertex(1000.0), fNTracksPassed(0), fNTracksFailed(0), fRemoveKinks(kFALSE), @@ -132,17 +135,40 @@ bool AliFemtoESDTrackCut::Pass(const AliFemtoTrack* track) } } + if (fRemoveKinks) { + if ((track->KinkIndex(0)) || (track->KinkIndex(1)) || (track->KinkIndex(2))) + return false; + } if (fminTPCclsF>track->TPCnclsF()) { //cout<<" No go because TPC Number of ClsF"<TPCnclsF()<track->TPCncls()) + { + //cout<<" No go because TPC Number of ClsF"<TPCnclsF()<track->ITSncls()) { //cout<<" No go because ITS Number of Cls"<ITSncls()<SigmaToVertex()) { + return false; + } + + if (track->ITSncls() > 0) + if ((track->ITSchi2()/track->ITSncls()) > fMaxITSchiNdof) { + return false; + } + + if (track->TPCncls() > 0) + if ((track->TPCchi2()/track->TPCncls()) > fMaxTPCchiNdof) { + return false; + } + if (fLabel) { //cout<<"labels"<KinkIndex(0)) || (track->KinkIndex(1)) || (track->KinkIndex(2))) - return false; - } if (fMostProbable) { tMost[0] = track->PidProbElectron()*PidFractionElectron(track->P().mag()); @@ -323,6 +345,12 @@ TList *AliFemtoESDTrackCut::ListSettings() tListSetttings->AddLast(new TObjString(buf)); snprintf(buf, 200, "AliFemtoESDTrackCut.removekinks=%i", fRemoveKinks); tListSetttings->AddLast(new TObjString(buf)); + snprintf(buf, 200, "AliFemtoESDTrackCut.maxitschindof=%lf", fMaxITSchiNdof); + tListSetttings->AddLast(new TObjString(buf)); + snprintf(buf, 200, "AliFemtoESDTrackCut.maxtpcchindof=%lf", fMaxTPCchiNdof); + tListSetttings->AddLast(new TObjString(buf)); + snprintf(buf, 200, "AliFemtoESDTrackCut.maxsigmatovertex=%lf", fMaxSigmaToVertex); + tListSetttings->AddLast(new TObjString(buf)); if (fMostProbable) { if (fMostProbable == 2) snprintf(buf, 200, "AliFemtoESDTrackCut.mostprobable=%s", "Pion"); diff --git a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoESDTrackCut.h b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoESDTrackCut.h index a90e5cf9214..acba7757ea7 100644 --- a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoESDTrackCut.h +++ b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoESDTrackCut.h @@ -28,6 +28,7 @@ class AliFemtoESDTrackCut : public AliFemtoTrackCut virtual AliFemtoString Report(); virtual TList *ListSettings(); + virtual AliFemtoParticleType Type(){return hbtTrack;} void SetPt(const float& lo, const float& hi); void SetRapidity(const float& lo, const float& hi); @@ -40,8 +41,12 @@ class AliFemtoESDTrackCut : public AliFemtoTrackCut void SetLabel(const bool& flag); void SetStatus(const long& w); void SetminTPCclsF(const short& s); + void SetminTPCncls(const short& s); void SetminITScls(const int& s); void SetRemoveKinks(const bool& flag); + void SetMaxITSChiNdof(const float& maxchi); + void SetMaxTPCChiNdof(const float& maxchi); + void SetMaxSigmaToVertex(const float& maxsig); void SetMostProbablePion(); void SetMostProbableKaon(); void SetMostProbableProton(); @@ -60,7 +65,11 @@ class AliFemtoESDTrackCut : public AliFemtoTrackCut bool fLabel; // if true label<0 will not pass throught long fStatus; // staus flag short fminTPCclsF; // min number of findable clusters in the TPC + short fminTPCncls; // min number of clusters in the TPC int fminITScls; // min number of clusters assigned in the ITS + float fMaxITSchiNdof; // maximum allowed chi2/ndof for ITS clusters + float fMaxTPCchiNdof; // maximum allowed chi2/ndof for TPC clusters + float fMaxSigmaToVertex; // maximum allowed sigma to primary vertex long fNTracksPassed; // passed tracks count long fNTracksFailed; // failed tracks count bool fRemoveKinks; // if true particles with any kink label will not pass @@ -88,11 +97,15 @@ inline void AliFemtoESDTrackCut::SetPidProbMuon(const float& lo,const float& hi) inline void AliFemtoESDTrackCut::SetLabel(const bool& flag){fLabel=flag;} inline void AliFemtoESDTrackCut::SetStatus(const long& status){fStatus=status;} inline void AliFemtoESDTrackCut::SetminTPCclsF(const short& minTPCclsF){fminTPCclsF=minTPCclsF;} +inline void AliFemtoESDTrackCut::SetminTPCncls(const short& s){fminTPCncls=s;} inline void AliFemtoESDTrackCut::SetminITScls(const int& minITScls){fminITScls=minITScls;} inline void AliFemtoESDTrackCut::SetMostProbablePion() { fMostProbable = 2; } inline void AliFemtoESDTrackCut::SetMostProbableKaon() { fMostProbable = 3; } inline void AliFemtoESDTrackCut::SetMostProbableProton() { fMostProbable = 4; } inline void AliFemtoESDTrackCut::SetNoMostProbable() { fMostProbable = 0; } +inline void AliFemtoESDTrackCut::SetMaxITSChiNdof(const float& maxchi) { fMaxITSchiNdof = maxchi; } +inline void AliFemtoESDTrackCut::SetMaxTPCChiNdof(const float& maxchi) { fMaxTPCchiNdof = maxchi; } +inline void AliFemtoESDTrackCut::SetMaxSigmaToVertex(const float& maxsig) { fMaxSigmaToVertex = maxsig; } #endif diff --git a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoEventReaderESDKine.cxx b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoEventReaderESDKine.cxx index 761795d5d45..4d1a04708c9 100644 --- a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoEventReaderESDKine.cxx +++ b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoEventReaderESDKine.cxx @@ -42,7 +42,7 @@ #include "AliESDtrack.h" #include "AliESDVertex.h" #include "AliStack.h" -#include "AliAODParticle.h" +//#include "AliAODParticle.h" #include "TParticle.h" //#include "TSystem.h" @@ -54,6 +54,8 @@ #include "AliFemtoEvent.h" +#include "TMath.h" + ClassImp(AliFemtoEventReaderESDKine) #if !(ST_NO_NAMESPACES) @@ -355,24 +357,44 @@ AliFemtoEvent* AliFemtoEventReaderESDKine::ReturnHbtEvent() trackCopy->SetTPCnclsF(esdtrack->GetTPCNclsF()); trackCopy->SetTPCsignalN((short)esdtrack->GetTPCsignalN()); //due to bug in aliesdtrack class trackCopy->SetTPCsignalS(esdtrack->GetTPCsignalSigma()); + trackCopy->SetSigmaToVertex(GetSigmaToVertex(esdtrack)); trackCopy->SetTPCClusterMap(esdtrack->GetTPCClusterMap()); trackCopy->SetTPCSharedMap(esdtrack->GetTPCSharedMap()); + double pvrt[3]; + fEvent->GetPrimaryVertex()->GetXYZ(pvrt); + + double xtpc[3]; + esdtrack->GetInnerXYZ(xtpc); + xtpc[2] -= pvrt[2]; + trackCopy->SetNominalTPCEntrancePoint(xtpc); + + esdtrack->GetOuterXYZ(xtpc); + xtpc[2] -= pvrt[2]; + trackCopy->SetNominalTPCExitPoint(xtpc); + + int indexes[3]; + for (int ik=0; ik<3; ik++) { + indexes[ik] = esdtrack->GetKinkIndex(ik); + } + trackCopy->SetKinkIndexes(indexes); + // Fill the hidden information with the simulated data TParticle *tPart = tStack->Particle(TMath::Abs(esdtrack->GetLabel())); - AliAODParticle* tParticle= new AliAODParticle(*tPart,i); + // AliAODParticle* tParticle= new AliAODParticle(*tPart,i); AliFemtoModelHiddenInfo *tInfo = new AliFemtoModelHiddenInfo(); - tInfo->SetPDGPid(tParticle->GetMostProbable()); - tInfo->SetTrueMomentum(tParticle->Px(), tParticle->Py(), tParticle->Pz()); - Double_t mass2 = (tParticle->E()*tParticle->E() - - tParticle->Px()*tParticle->Px() - - tParticle->Py()*tParticle->Py() - - tParticle->Pz()*tParticle->Pz()); + tInfo->SetPDGPid(tPart->GetPdgCode()); + tInfo->SetTrueMomentum(tPart->Px(), tPart->Py(), tPart->Pz()); + Double_t mass2 = (tPart->Energy() *tPart->Energy() - + tPart->Px()*tPart->Px() - + tPart->Py()*tPart->Py() - + tPart->Pz()*tPart->Pz()); if (mass2>0.0) tInfo->SetMass(TMath::Sqrt(mass2)); else tInfo->SetMass(0.0); + tInfo->SetEmissionPoint(tPart->Vx()*1e13, tPart->Vy()*1e13, tPart->Vz()*1e13, tPart->T()*1e13*300000); trackCopy->SetHiddenInfo(tInfo); //decision if we want this track @@ -401,3 +423,43 @@ AliFemtoEvent* AliFemtoEventReaderESDKine::ReturnHbtEvent() } return hbtEvent; } +//____________________________________________________________________ +Float_t AliFemtoEventReaderESDKine::GetSigmaToVertex(const AliESDtrack* esdTrack) +{ + // Calculates the number of sigma to the vertex. + + Float_t b[2]; + Float_t bRes[2]; + Float_t bCov[3]; + esdTrack->GetImpactParameters(b,bCov); +// if (bCov[0]<=0 || bCov[2]<=0) { +// AliDebug(1, "Estimated b resolution lower or equal zero!"); +// bCov[0]=0; bCov[2]=0; +// } + bRes[0] = TMath::Sqrt(bCov[0]); + bRes[1] = TMath::Sqrt(bCov[2]); + + // ----------------------------------- + // How to get to a n-sigma cut? + // + // The accumulated statistics from 0 to d is + // + // -> Erf(d/Sqrt(2)) for a 1-dim gauss (d = n_sigma) + // -> 1 - Exp(-d**2) for a 2-dim gauss (d*d = dx*dx + dy*dy != n_sigma) + // + // It means that for a 2-dim gauss: n_sigma(d) = Sqrt(2)*ErfInv(1 - Exp((-x**2)/2) + // Can this be expressed in a different way? + + if (bRes[0] == 0 || bRes[1] ==0) + return -1; + + Float_t d = TMath::Sqrt(TMath::Power(b[0]/bRes[0],2) + TMath::Power(b[1]/bRes[1],2)); + + // stupid rounding problem screws up everything: + // if d is too big, TMath::Exp(...) gets 0, and TMath::ErfInverse(1) that should be infinite, gets 0 :( + if (TMath::Exp(-d * d / 2) < 1e-10) + return 1000; + + d = TMath::ErfInverse(1 - TMath::Exp(-d * d / 2)) * TMath::Sqrt(2); + return d; +} diff --git a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoEventReaderESDKine.h b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoEventReaderESDKine.h index 5a8acf70985..cb6b4ae44da 100644 --- a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoEventReaderESDKine.h +++ b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoEventReaderESDKine.h @@ -38,6 +38,7 @@ #include #include #include "TChain.h" +#include "AliESDtrack.h" #include "AliESDEvent.h" #include #include "AliRunLoader.h" @@ -74,6 +75,8 @@ class AliFemtoEventReaderESDKine : public AliFemtoEventReader AliESDEvent* fEvent; // ESD event AliRunLoader* fRunLoader; // Run loader for kine reading + Float_t GetSigmaToVertex(const AliESDtrack* esdTrack); + #ifdef __ROOT__ ClassDef(AliFemtoEventReaderESDKine, 1) #endif diff --git a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoModelBPLCMSCorrFctn.cxx b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoModelBPLCMSCorrFctn.cxx index 628f9bfe5a5..336bbccd42c 100644 --- a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoModelBPLCMSCorrFctn.cxx +++ b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoModelBPLCMSCorrFctn.cxx @@ -22,25 +22,25 @@ AliFemtoModelBPLCMSCorrFctn::AliFemtoModelBPLCMSCorrFctn(char* title, const int& fNumerator3DTrue(0), fNumerator3DFake(0), fDenominator3D(0), - fQinvHisto(0) + fQinvHisto(0), + fPairCut(0) { - // set up true numerator - char TitNumT[100] = "Num3DTrue"; - strcat(TitNumT,title); - fNumerator3DTrue = new TH3D(TitNumT,title,nbins,QLo,QHi,nbins,QLo,QHi,nbins,QLo,QHi); + char tTitNumT[100] = "Num3DTrue"; + strcat(tTitNumT,title); + fNumerator3DTrue = new TH3D(tTitNumT,title,nbins,QLo,QHi,nbins,QLo,QHi,nbins,QLo,QHi); // set up fake numerator - char TitNumF[100] = "Num3DFake"; - strcat(TitNumF,title); - fNumerator3DFake = new TH3D(TitNumF,title,nbins,QLo,QHi,nbins,QLo,QHi,nbins,QLo,QHi); + char tTitNumF[100] = "Num3DFake"; + strcat(tTitNumF,title); + fNumerator3DFake = new TH3D(tTitNumF,title,nbins,QLo,QHi,nbins,QLo,QHi,nbins,QLo,QHi); // set up denominator - char TitDen[100] = "Den3D"; - strcat(TitDen,title); - fDenominator3D = new TH3D(TitDen,title,nbins,QLo,QHi,nbins,QLo,QHi,nbins,QLo,QHi); + char tTitDen[100] = "Den3D"; + strcat(tTitDen,title); + fDenominator3D = new TH3D(tTitDen,title,nbins,QLo,QHi,nbins,QLo,QHi,nbins,QLo,QHi); // set up ave qInv - char TitQinv[100] = "Qinv"; - strcat(TitQinv,title); - fQinvHisto = new TH3D(TitQinv,title,nbins,QLo,QHi,nbins,QLo,QHi,nbins,QLo,QHi); + char tTitQinv[100] = "Qinv"; + strcat(tTitQinv,title); + fQinvHisto = new TH3D(tTitQinv,title,nbins,QLo,QHi,nbins,QLo,QHi,nbins,QLo,QHi); // to enable error bar calculation... fNumerator3DTrue->Sumw2(); @@ -53,16 +53,20 @@ AliFemtoModelBPLCMSCorrFctn::AliFemtoModelBPLCMSCorrFctn(const AliFemtoModelBPLC fNumerator3DTrue(0), fNumerator3DFake(0), fDenominator3D(0), - fQinvHisto(0) + fQinvHisto(0), + fPairCut(0) { + // Copy constructor fNumerator3DTrue = new TH3D(*aCorrFctn.fNumerator3DTrue); fNumerator3DFake = new TH3D(*aCorrFctn.fNumerator3DFake); fDenominator3D = new TH3D(*aCorrFctn.fDenominator3D); fQinvHisto = new TH3D(*aCorrFctn.fQinvHisto); + fPairCut = aCorrFctn.fPairCut->Clone(); } //____________________________ AliFemtoModelBPLCMSCorrFctn::~AliFemtoModelBPLCMSCorrFctn() { + // destructor if (fNumeratorTrue) delete fNumeratorTrue; if (fNumeratorFake) delete fNumeratorFake; if (fDenominator) delete fDenominator; @@ -70,10 +74,12 @@ AliFemtoModelBPLCMSCorrFctn::~AliFemtoModelBPLCMSCorrFctn() delete fNumerator3DFake; delete fDenominator3D; delete fQinvHisto; + if (fPairCut) delete fPairCut; } //_________________________ AliFemtoModelBPLCMSCorrFctn& AliFemtoModelBPLCMSCorrFctn::operator=(const AliFemtoModelBPLCMSCorrFctn& aCorrFctn) { + // Assignment operator if (this == &aCorrFctn) return *this; if (fNumerator3DTrue) delete fNumerator3DTrue; @@ -84,18 +90,33 @@ AliFemtoModelBPLCMSCorrFctn& AliFemtoModelBPLCMSCorrFctn::operator=(const AliFem fDenominator3D = new TH3D(*aCorrFctn.fDenominator3D); if (fQinvHisto) delete fQinvHisto; fQinvHisto = new TH3D(*aCorrFctn.fQinvHisto); + fPairCut = aCorrFctn.fPairCut->Clone(); return *this; } //_________________________ void AliFemtoModelBPLCMSCorrFctn::Write(){ + // Write out data histograms AliFemtoModelCorrFctn::Write(); fNumerator3DTrue->Write(); fNumerator3DFake->Write(); fDenominator3D->Write(); fQinvHisto->Write(); } +//________________________ +TList* AliFemtoModelBPLCMSCorrFctn::GetOutputList() +{ + // Prepare the list of objects to be written to the output + TList *tOutputList = AliFemtoModelCorrFctn::GetOutputList(); + + tOutputList->Add(fNumerator3DTrue); + tOutputList->Add(fNumerator3DFake); + tOutputList->Add(fDenominator3D); + tOutputList->Add(fQinvHisto); + + return tOutputList; +} //_________________________ void AliFemtoModelBPLCMSCorrFctn::Finish(){ @@ -104,6 +125,7 @@ void AliFemtoModelBPLCMSCorrFctn::Finish(){ //____________________________ AliFemtoString AliFemtoModelBPLCMSCorrFctn::Report(){ + // Prepare a report from the execution string stemp = "LCMS Frame Bertsch-Pratt 3D Model Correlation Function Report:\n"; char ctemp[100]; sprintf(ctemp,"Number of entries in numerator:\t%E\n",fNumeratorTrue->GetEntries()); @@ -127,7 +149,13 @@ AliFemtoString AliFemtoModelBPLCMSCorrFctn::Report(){ return returnThis; } //____________________________ -void AliFemtoModelBPLCMSCorrFctn::AddRealPair( AliFemtoPair* pair){ +void AliFemtoModelBPLCMSCorrFctn::AddRealPair( AliFemtoPair* pair) +{ + // Store a real pair in numerator + if (fPairCut){ + if (!(fPairCut->Pass(pair))) return; + } + Double_t weight = fManager->GetWeight(pair); double qOut = fabs(pair->QOutCMS()); @@ -139,6 +167,11 @@ void AliFemtoModelBPLCMSCorrFctn::AddRealPair( AliFemtoPair* pair){ } //____________________________ void AliFemtoModelBPLCMSCorrFctn::AddMixedPair( AliFemtoPair* pair){ + // store mixed pair in denominator + if (fPairCut){ + if (!(fPairCut->Pass(pair))) return; + } + Double_t weight = fManager->GetWeight(pair); double qOut = fabs(pair->QOutCMS()); @@ -159,3 +192,8 @@ AliFemtoModelCorrFctn* AliFemtoModelBPLCMSCorrFctn::Clone() return tCopy; } + +void AliFemtoModelBPLCMSCorrFctn::SetSpecificPairCut(AliFemtoPairCut* aCut) +{ + fPairCut = aCut; +} diff --git a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoModelBPLCMSCorrFctn.h b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoModelBPLCMSCorrFctn.h index 47a5bd6ec14..3ba4d558078 100644 --- a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoModelBPLCMSCorrFctn.h +++ b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoModelBPLCMSCorrFctn.h @@ -6,8 +6,8 @@ /// Authors: Adam Kisiel, kisiel@mps.ohio-state.edu /// /// /// //////////////////////////////////////////////////////////////////////////////// -#ifndef AliFemtoModelBPLCMSCorrFctn_hh -#define AliFemtoModelBPLCMSCorrFctn_hh +#ifndef ALIFEMTOMODELBPLCMSCORRFCTN_H +#define ALIFEMTOMODELBPLCMSCORRFCTN_H #include "AliFemtoCorrFctn.h" #include "AliFemtoModelCorrFctn.h" @@ -24,12 +24,15 @@ class AliFemtoModelBPLCMSCorrFctn : public AliFemtoModelCorrFctn { AliFemtoModelBPLCMSCorrFctn& operator=(const AliFemtoModelBPLCMSCorrFctn& aCorrFctn); virtual AliFemtoString Report(); - virtual void AddRealPair(AliFemtoPair*); - virtual void AddMixedPair(AliFemtoPair*); + virtual void AddRealPair(AliFemtoPair* pair); + virtual void AddMixedPair(AliFemtoPair* pair); virtual void Finish(); virtual void Write(); + virtual TList* GetOutputList(); + + void SetSpecificPairCut(AliFemtoPairCut* aCut); virtual AliFemtoModelCorrFctn* Clone(); @@ -40,6 +43,8 @@ protected: TH3D* fQinvHisto; // Averag qinv histogram + AliFemtoPairCut* fPairCut; //! this is a PairCut specific to THIS CorrFctn, not the Analysis + #ifdef __ROOT__ ClassDef(AliFemtoModelBPLCMSCorrFctn, 1) #endif diff --git a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoModelCorrFctnSource.cxx b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoModelCorrFctnSource.cxx index a9c5b914e90..1b7ecdb1325 100644 --- a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoModelCorrFctnSource.cxx +++ b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoModelCorrFctnSource.cxx @@ -164,6 +164,20 @@ void AliFemtoModelCorrFctnSource::Write() AliFemtoModelCorrFctn::Write(); } +//________________________ +TList* AliFemtoModelCorrFctnSource::GetOutputList() +{ + // Prepare the list of objects to be written to the output + TList *tOutputList = AliFemtoModelCorrFctn::GetOutputList(); + + tOutputList->Add(fHistROut); + tOutputList->Add(fHistRSide); + tOutputList->Add(fHistRLong); + tOutputList->Add(fHistRStar); + tOutputList->Add(fHistdNdR); + + return tOutputList; +} //_______________________ AliFemtoModelCorrFctn* AliFemtoModelCorrFctnSource::Clone() { diff --git a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoModelCorrFctnSource.h b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoModelCorrFctnSource.h index dda269a5398..f4265cdfd10 100644 --- a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoModelCorrFctnSource.h +++ b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoModelCorrFctnSource.h @@ -30,6 +30,7 @@ public: virtual void AddMixedPair(AliFemtoPair* aPir); virtual void Write(); + virtual TList* GetOutputList(); virtual AliFemtoModelCorrFctn* Clone(); diff --git a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoModelCorrFctnTrueQ.cxx b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoModelCorrFctnTrueQ.cxx new file mode 100644 index 00000000000..4e6c16bbabc --- /dev/null +++ b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoModelCorrFctnTrueQ.cxx @@ -0,0 +1,138 @@ +//////////////////////////////////////////////////////////////////////////////// +/// /// +/// AliFemtoModelCorrFctnTrueQ - the class for correlation function which /// +/// uses the model framework and weight generation and saves the generated /// +/// emission source /// +/// Authors: Adam Kisiel, kisiel@mps.ohio-state.edu /// +/// /// +//////////////////////////////////////////////////////////////////////////////// +#ifdef __ROOT__ + ClassImp(AliFemtoModelCorrFctnTrueQ, 1) +#endif + +#include "AliFemtoModelGausLCMSFreezeOutGenerator.h" +#include "AliFemtoModelHiddenInfo.h" +#include "AliFemtoModelCorrFctnTrueQ.h" + +//_______________________ +AliFemtoModelCorrFctnTrueQ::AliFemtoModelCorrFctnTrueQ(): + AliFemtoModelCorrFctn(), + fTrueNum(0), + fTrueDen(0) +{ + // default constructor + char buf[100]; + char title[100] = "CFTrueQ"; + sprintf(buf, "%sNum", title); + fTrueNum = new TH1D(buf,buf,100,0.0,0.4); + sprintf(buf, "%sDen", title); + fTrueDen = new TH1D(buf,buf,100,0.0,0.4); + + fTrueNum->Sumw2(); + fTrueDen->Sumw2(); +} +//_______________________ +AliFemtoModelCorrFctnTrueQ::AliFemtoModelCorrFctnTrueQ(const char *title, Int_t aNbins, Double_t aQinvLo, Double_t aQinvHi): + AliFemtoModelCorrFctn(title, aNbins, aQinvLo, aQinvHi), + fTrueNum(0), + fTrueDen(0) +{ + // basic constructor + char buf[100]; + sprintf(buf, "%sTrueQNum", title); + fTrueNum = new TH1D(buf,buf,aNbins,aQinvLo,aQinvHi); + sprintf(buf, "%sTrueQDen", title); + fTrueDen = new TH1D(buf,buf,aNbins,aQinvLo,aQinvHi); + + fTrueNum->Sumw2(); + fTrueDen->Sumw2(); +} +//_______________________ +AliFemtoModelCorrFctnTrueQ::AliFemtoModelCorrFctnTrueQ(const AliFemtoModelCorrFctnTrueQ& aCorrFctn): + AliFemtoModelCorrFctn(aCorrFctn), + fTrueNum(0), + fTrueDen(0) +{ + // copy constructor + fTrueNum = new TH1D(*aCorrFctn.fTrueNum); + fTrueDen = new TH1D(*aCorrFctn.fTrueDen); +} +//_______________________ +AliFemtoModelCorrFctnTrueQ::~AliFemtoModelCorrFctnTrueQ() +{ + // destructor + if (fTrueNum) delete fTrueNum; + if (fTrueDen) delete fTrueDen; + if (fNumeratorTrue) delete fNumeratorTrue; + if (fNumeratorFake) delete fNumeratorFake; + if (fDenominator) delete fDenominator; +} + +//_______________________ +AliFemtoModelCorrFctnTrueQ& AliFemtoModelCorrFctnTrueQ::operator=(const AliFemtoModelCorrFctnTrueQ& aCorrFctn) +{ + // assignment operator + if (this == &aCorrFctn) + return *this; + if (aCorrFctn.fTrueNum) + fTrueNum = new TH1D (*aCorrFctn.fTrueNum); + else fTrueNum = 0; + if (aCorrFctn.fTrueDen) + fTrueDen = new TH1D(*aCorrFctn.fTrueDen); + else fTrueDen = 0; + + return *this; +} +//_______________________ +AliFemtoString AliFemtoModelCorrFctnTrueQ::Report() +{ + // construct report + AliFemtoString tStr = "AliFemtoModelCorrFctnTrueQ report"; + + return tStr; +} + +//_______________________ +void AliFemtoModelCorrFctnTrueQ::AddRealPair(AliFemtoPair* aPair) +{ + // add real (effect) pair + AliFemtoModelCorrFctn::AddRealPair(aPair); + fTrueNum->Fill(fManager->GetWeightGenerator()->GetKStar()*2); +} +//_______________________ +void AliFemtoModelCorrFctnTrueQ::AddMixedPair(AliFemtoPair* aPair) +{ + // add mixed (background) pair + AliFemtoModelCorrFctn::AddMixedPair(aPair); + // save the generated positions + fTrueDen->Fill(fManager->GetWeightGenerator()->GetKStar()*2); +} +//_______________________ +void AliFemtoModelCorrFctnTrueQ::Write() +{ + // write out all the histograms + fTrueNum->Write(); + fTrueDen->Write(); + + AliFemtoModelCorrFctn::Write(); +} +//_______________________ +TList* AliFemtoModelCorrFctnTrueQ::GetOutputList() +{ + // Prepare the list of objects to be written to the output + TList *tOutputList = AliFemtoModelCorrFctn::GetOutputList(); + + tOutputList->Add(fTrueNum); + tOutputList->Add(fTrueDen); + + return tOutputList; +} +//_______________________ +AliFemtoModelCorrFctn* AliFemtoModelCorrFctnTrueQ::Clone() +{ + // Clone the correlation function + AliFemtoModelCorrFctnTrueQ *tCopy = new AliFemtoModelCorrFctnTrueQ(*this); + + return tCopy; +} + diff --git a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoModelCorrFctnTrueQ.h b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoModelCorrFctnTrueQ.h new file mode 100644 index 00000000000..e2f892dab2b --- /dev/null +++ b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoModelCorrFctnTrueQ.h @@ -0,0 +1,49 @@ +//////////////////////////////////////////////////////////////////////////////// +/// /// +/// AliFemtoModelCorrFctnTrueQ - the class for correlation function which /// +/// uses the model framework and weight generation and saves the correlation /// +/// function in true qinv /// +/// Authors: Adam Kisiel, kisiel@mps.ohio-state.edu /// +/// /// +//////////////////////////////////////////////////////////////////////////////// +#ifndef ALIFEMTOMODELCORRFCTNTRUEQ_H +#define ALIFEMTOMODELCORRFCTNTRUEQ_H + +#include "AliFemtoCorrFctn.h" +#include "AliFemtoPair.h" +#include "AliFemtoModelManager.h" +#include "AliFemtoModelCorrFctn.h" + +class AliFemtoModelCorrFctnTrueQ: public AliFemtoModelCorrFctn { + +public: + AliFemtoModelCorrFctnTrueQ(); + AliFemtoModelCorrFctnTrueQ(const char *title, Int_t aNbins, Double_t aQinvLo, Double_t aQinvHi); + AliFemtoModelCorrFctnTrueQ(const AliFemtoModelCorrFctnTrueQ& aCorrFctn); + virtual ~AliFemtoModelCorrFctnTrueQ(); + + AliFemtoModelCorrFctnTrueQ& operator=(const AliFemtoModelCorrFctnTrueQ& aCorrFctn); + + virtual AliFemtoString Report(); + + virtual void AddRealPair(AliFemtoPair* aPair); + virtual void AddMixedPair(AliFemtoPair* aPir); + + virtual void Write(); + virtual TList* GetOutputList(); + + virtual AliFemtoModelCorrFctn* Clone(); + +protected: + + TH1D *fTrueNum; // Numerator in true q + TH1D *fTrueDen; // Denominator in true q + +private: + +#ifdef __ROOT__ + ClassDef(AliFemtoModelCorrFctnTrueQ, 1) +#endif +}; + +#endif diff --git a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityCorrFctn.cxx b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityCorrFctn.cxx index 0effcc86d4e..27c9f4cb3a4 100644 --- a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityCorrFctn.cxx +++ b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityCorrFctn.cxx @@ -135,7 +135,7 @@ AliFemtoString AliFemtoShareQualityCorrFctn::Report(){ //____________________________ void AliFemtoShareQualityCorrFctn::AddRealPair( AliFemtoPair* pair){ // add real (effect) pair - // double tQinv = fabs(pair->QInv()); // note - qInv() will be negative for identical pairs... + double tQinv = fabs(pair->QInv()); // note - qInv() will be negative for identical pairs... Int_t nh = 0; Int_t an = 0; Int_t ns = 0; @@ -195,49 +195,57 @@ void AliFemtoShareQualityCorrFctn::AddRealPair( AliFemtoPair* pair){ hsfval = ns*1.0/nh; } -// if ((tQinv < 0.01) && (hsmval<-0.46)) { -// cout << "Quality Sharity " << hsmval << " " << hsfval << " " << pair->Track1()->Track() << " " << pair->Track2()->Track() << endl; -// cout << "Qinv of the pair is " << tQinv << endl; -// cout << "Clusters: " << endl; -// for (unsigned int imap=0; imapTrack1()->Track()->TPCclusters().GetNbits(); imap++) { -// cout << imap ; -// if (pair->Track1()->Track()->TPCclusters().TestBitNumber(imap)) cout << " 1 "; -// else cout << " 0 " ; -// if (pair->Track2()->Track()->TPCclusters().TestBitNumber(imap)) cout << " 1 "; -// else cout << " 0 " ; -// cout << " "; -// if (pair->Track1()->Track()->TPCsharing().TestBitNumber(imap)) cout << " S "; -// else cout << " X "; -// if (pair->Track2()->Track()->TPCsharing().TestBitNumber(imap)) cout << " S "; -// else cout << " X "; -// cout << endl; -// } -// cout << "Momentum1 " -// << pair->Track1()->Track()->P().x() << " " -// << pair->Track1()->Track()->P().y() << " " -// << pair->Track1()->Track()->P().z() << " " -// << pair->Track1()->Track()->Label() << " " -// << pair->Track1()->Track()->TrackId() << " " -// << pair->Track1()->Track()->Flags() << " " -// << pair->Track1()->Track()->KinkIndex(0) << " " -// << pair->Track1()->Track()->KinkIndex(1) << " " -// << pair->Track1()->Track()->KinkIndex(2) << " " -// << endl; -// cout << "Momentum2 " -// << pair->Track2()->Track()->P().x() << " " -// << pair->Track2()->Track()->P().y() << " " -// << pair->Track2()->Track()->P().z() << " " -// << pair->Track2()->Track()->Label() << " " -// << pair->Track2()->Track()->TrackId() << " " -// << pair->Track2()->Track()->Flags() << " " -// << pair->Track2()->Track()->KinkIndex(0) << " " -// << pair->Track2()->Track()->KinkIndex(1) << " " -// << pair->Track2()->Track()->KinkIndex(2) << " " -// << endl; -// } + if ((tQinv < 0.005) && (hsmval<-0.0)) { + cout << "Quality Sharity " << hsmval << " " << hsfval << " " << pair->Track1()->Track() << " " << pair->Track2()->Track() << endl; + cout << "Qinv of the pair is " << tQinv << endl; + cout << "Clusters: " << endl; + for (unsigned int imap=0; imapTrack1()->Track()->TPCclusters().GetNbits(); imap++) { + cout << imap ; + if (pair->Track1()->Track()->TPCclusters().TestBitNumber(imap)) cout << " 1 "; + else cout << " 0 " ; + if (pair->Track2()->Track()->TPCclusters().TestBitNumber(imap)) cout << " 1 "; + else cout << " 0 " ; + cout << " "; + if (pair->Track1()->Track()->TPCsharing().TestBitNumber(imap)) cout << " S "; + else cout << " X "; + if (pair->Track2()->Track()->TPCsharing().TestBitNumber(imap)) cout << " S "; + else cout << " X "; + cout << endl; + } + cout << "Momentum1 " + << pair->Track1()->Track()->P().x() << " " + << pair->Track1()->Track()->P().y() << " " + << pair->Track1()->Track()->P().z() << " " + << pair->Track1()->Track()->Label() << " " + << pair->Track1()->Track()->TrackId() << " " + << pair->Track1()->Track()->Flags() << " " + << pair->Track1()->Track()->KinkIndex(0) << " " + << pair->Track1()->Track()->KinkIndex(1) << " " + << pair->Track1()->Track()->KinkIndex(2) << " " + << pair->Track1()->Track()->ITSchi2() << " " + << pair->Track1()->Track()->ITSncls() << " " + << pair->Track1()->Track()->TPCchi2() << " " + << pair->Track1()->Track()->TPCncls() << " " + << endl; + cout << "Momentum2 " + << pair->Track2()->Track()->P().x() << " " + << pair->Track2()->Track()->P().y() << " " + << pair->Track2()->Track()->P().z() << " " + << pair->Track2()->Track()->Label() << " " + << pair->Track2()->Track()->TrackId() << " " + << pair->Track2()->Track()->Flags() << " " + << pair->Track2()->Track()->KinkIndex(0) << " " + << pair->Track2()->Track()->KinkIndex(1) << " " + << pair->Track2()->Track()->KinkIndex(2) << " " + << pair->Track2()->Track()->ITSchi2() << " " + << pair->Track2()->Track()->ITSncls() << " " + << pair->Track2()->Track()->TPCchi2() << " " + << pair->Track2()->Track()->TPCncls() << " " + << endl; + } -// fShareNumerator->Fill(tQinv, hsfval); -// fQualityNumerator->Fill(tQinv, hsmval); + fShareNumerator->Fill(tQinv, hsfval); + fQualityNumerator->Fill(tQinv, hsmval); // cout << "AliFemtoShareQualityCorrFctn::AddRealPair : " << pair->qInv() << " " << tQinv << //" " << pair->Track1().FourMomentum() << " " << pair->Track2().FourMomentum() << endl; } @@ -296,9 +304,23 @@ void AliFemtoShareQualityCorrFctn::AddMixedPair( AliFemtoPair* pair){ void AliFemtoShareQualityCorrFctn::WriteHistos() { + // Write out result histograms fShareNumerator->Write(); fShareDenominator->Write(); fQualityNumerator->Write(); fQualityDenominator->Write(); } +//______________________________ +TList* AliFemtoShareQualityCorrFctn::GetOutputList() +{ + // Prepare the list of objects to be written to the output + TList *tOutputList = new TList(); + + tOutputList->Add(fShareNumerator); + tOutputList->Add(fShareDenominator); + tOutputList->Add(fQualityNumerator); + tOutputList->Add(fQualityDenominator); + + return tOutputList; +} diff --git a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityCorrFctn.h b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityCorrFctn.h index ec644f7b7ed..5d85d83f468 100644 --- a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityCorrFctn.h +++ b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityCorrFctn.h @@ -28,6 +28,7 @@ public: virtual void Finish(); void WriteHistos(); + virtual TList* GetOutputList(); private: TH2D *fShareNumerator; // Share fraction for real pairs diff --git a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityKTPairCut.cxx b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityKTPairCut.cxx new file mode 100644 index 00000000000..9be80ada172 --- /dev/null +++ b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityKTPairCut.cxx @@ -0,0 +1,101 @@ +///////////////////////////////////////////////////////////////////////////// +// // +// AliFemtoShareQualityKTPairCut - a pair cut which checks for some pair // +// qualities that attempt to identify slit/doubly reconstructed tracks // +// and selects pairs based on their transverse momentum kT // +// // +///////////////////////////////////////////////////////////////////////////// +/*************************************************************************** + * + * $Id: AliFemtoShareQualityKTPairCut.cxx,v 1.1.2.1 2007/10/19 13:35:33 akisiel Exp $ + * + * Author: Adam Kisiel, Ohio State, kisiel@mps.ohio-state.edu + *************************************************************************** + * + * Description: part of STAR HBT Framework: AliFemtoMaker package + * a cut to remove "shared" and "split" pairs + * + *************************************************************************** + * + * + **************************************************************************/ + +#include "AliFemtoShareQualityKTPairCut.h" +#include +#include + +#ifdef __ROOT__ +ClassImp(AliFemtoShareQualityKTPairCut) +#endif + +//__________________ +AliFemtoShareQualityKTPairCut::AliFemtoShareQualityKTPairCut(): + AliFemtoShareQualityPairCut(), + fKTMin(0), + fKTMax(1.0e6) +{ +} +//__________________ +AliFemtoShareQualityKTPairCut::AliFemtoShareQualityKTPairCut(const AliFemtoShareQualityKTPairCut& c) : + AliFemtoShareQualityPairCut(c), + fKTMin(0), + fKTMax(1.0e6) +{ + fKTMin = c.fKTMin; + fKTMax = c.fKTMax; +} + +//__________________ +AliFemtoShareQualityKTPairCut::~AliFemtoShareQualityKTPairCut(){ + /* no-op */ +} +//__________________ +bool AliFemtoShareQualityKTPairCut::Pass(const AliFemtoPair* pair){ + // Accept a pair base on its Kt and sharity and quality + bool temp = true; + + if (pair->KT() < fKTMin) + temp = false; + + if (pair->KT() > fKTMax) + temp = false; + + if (temp) { + temp = AliFemtoShareQualityPairCut::Pass(pair); + } + else + fNPairsFailed++; + + return temp; +} +//__________________ +AliFemtoString AliFemtoShareQualityKTPairCut::Report(){ + // Prepare a report from execution + string stemp = "AliFemtoShareQuality Pair Cut - remove shared and split pairs\n"; char ctemp[100]; + sprintf(ctemp,"Accept pair with kT in range %lf , %lf",fKTMin,fKTMax); + stemp += ctemp; + sprintf(ctemp,"Number of pairs which passed:\t%ld Number which failed:\t%ld\n",fNPairsPassed,fNPairsFailed); + stemp += ctemp; + AliFemtoString returnThis = stemp; + return returnThis;} +//__________________ + +TList *AliFemtoShareQualityKTPairCut::ListSettings() +{ + // return a list of settings in a writable form + TList *tListSetttings = AliFemtoShareQualityPairCut::ListSettings(); + char buf[200]; + snprintf(buf, 200, "AliFemtoShareQualityKTPairCut.ktmax=%lf", fKTMax); + tListSetttings->AddLast(new TObjString(buf)); + snprintf(buf, 200, "AliFemtoShareQualityKTPairCut.ktmin=%lf", fKTMin); + tListSetttings->AddLast(new TObjString(buf)); + + return tListSetttings; +} + +void AliFemtoShareQualityKTPairCut::SetKTRange(double ktmin, double ktmax) +{ + // Set the accepted kT range + fKTMin = ktmin; + fKTMax = ktmax; +} diff --git a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityKTPairCut.h b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityKTPairCut.h new file mode 100644 index 00000000000..959a977d0ba --- /dev/null +++ b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityKTPairCut.h @@ -0,0 +1,51 @@ +/*************************************************************************** + * + * $Id: AliFemtoShareQualityKTPairCut.h,v 1.1.2.1 2007/10/19 13:35:33 akisiel Exp $ + * + * Author: Adam Kisiel, Ohio State University, kisiel@mps.ohio-state.edu + *************************************************************************** + * + * Description: part of STAR HBT Framework: AliFemtoMaker package + * a cut to remove "shared" and "split" pairs + * + *************************************************************************** + * + * + **************************************************************************/ + + +#ifndef ALIFEMTOSHAREQUALITYKTPAIRCUT_H +#define ALIFEMTOSHAREQUALITYKTPAIRCUT_H + +// do I need these lines ? +//#ifndef StMaker_H +//#include "StMaker.h" +//#endif + +#include "AliFemtoPairCut.h" +#include "AliFemtoShareQualityPairCut.h" + +class AliFemtoShareQualityKTPairCut : public AliFemtoShareQualityPairCut{ +public: + AliFemtoShareQualityKTPairCut(); + AliFemtoShareQualityKTPairCut(const AliFemtoShareQualityKTPairCut& c); + virtual ~AliFemtoShareQualityKTPairCut(); + + virtual bool Pass(const AliFemtoPair* pair); + virtual AliFemtoString Report(); + virtual TList *ListSettings(); + AliFemtoShareQualityKTPairCut* Clone(); + void SetKTRange(double ktmin, double ktmax); + + protected: + Double_t fKTMin; // Minimum allowed pair transverse momentum + Double_t fKTMax; // Maximum allowed pair transverse momentum + +#ifdef __ROOT__ + ClassDef(AliFemtoShareQualityKTPairCut, 0) +#endif +}; + +inline AliFemtoShareQualityKTPairCut* AliFemtoShareQualityKTPairCut::Clone() { AliFemtoShareQualityKTPairCut* c = new AliFemtoShareQualityKTPairCut(*this); return c;} + +#endif diff --git a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityPairCut.h b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityPairCut.h index e355fe1e729..39ef171ee05 100644 --- a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityPairCut.h +++ b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityPairCut.h @@ -39,7 +39,7 @@ public: virtual bool Pass(const AliFemtoPair* pair); virtual AliFemtoString Report(); virtual TList *ListSettings(); - AliFemtoShareQualityPairCut* Clone(); + virtual AliFemtoPairCut* Clone(); void SetShareQualityMax(Double_t aAliFemtoShareQualityMax); Double_t GetAliFemtoShareQualityMax() const; void SetShareFractionMax(Double_t aAliFemtoShareFractionMax); @@ -69,6 +69,6 @@ inline AliFemtoShareQualityPairCut::AliFemtoShareQualityPairCut(const AliFemtoSh fShareFractionMax(1.0)// no cut { /* no-op */ } -inline AliFemtoShareQualityPairCut* AliFemtoShareQualityPairCut::Clone() { AliFemtoShareQualityPairCut* c = new AliFemtoShareQualityPairCut(*this); return c;} +inline AliFemtoPairCut* AliFemtoShareQualityPairCut::Clone() { AliFemtoShareQualityPairCut* c = new AliFemtoShareQualityPairCut(*this); return c;} #endif diff --git a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityTPCEntranceSepPairCut.cxx b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityTPCEntranceSepPairCut.cxx new file mode 100644 index 00000000000..beeaa5b2279 --- /dev/null +++ b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityTPCEntranceSepPairCut.cxx @@ -0,0 +1,97 @@ +///////////////////////////////////////////////////////////////////////////// +// // +// AliFemtoShareQualityTPCEntranceSepPairCut - a pair cut which checks // +// for some pair qualities that attempt to identify slit/doubly // +// reconstructed tracks and also selects pairs based on their separation // +// at the entrance to the TPC // +// // +///////////////////////////////////////////////////////////////////////////// +/*************************************************************************** + * + * $Id: AliFemtoShareQualityTPCEntranceSepPairCut.cxx,v 1.1.2.1 2007/10/19 13:35:33 akisiel Exp $ + * + * Author: Adam Kisiel, Ohio State, kisiel@mps.ohio-state.edu + *************************************************************************** + * + * Description: part of STAR HBT Framework: AliFemtoMaker package + * a cut to remove "shared" and "split" pairs + * + *************************************************************************** + * + * + **************************************************************************/ + +#include "AliFemtoShareQualityTPCEntranceSepPairCut.h" +#include +#include + +#ifdef __ROOT__ +ClassImp(AliFemtoShareQualityTPCEntranceSepPairCut) +#endif + +//__________________ +AliFemtoShareQualityTPCEntranceSepPairCut::AliFemtoShareQualityTPCEntranceSepPairCut(): + AliFemtoShareQualityPairCut(), + fDTPCMin(0) +{ +} +//__________________ +AliFemtoShareQualityTPCEntranceSepPairCut::AliFemtoShareQualityTPCEntranceSepPairCut(const AliFemtoShareQualityTPCEntranceSepPairCut& c) : + AliFemtoShareQualityPairCut(c), + fDTPCMin(0) +{ + fDTPCMin = c.fDTPCMin; +} + +//__________________ +AliFemtoShareQualityTPCEntranceSepPairCut::~AliFemtoShareQualityTPCEntranceSepPairCut(){ + /* no-op */ +} +//__________________ +bool AliFemtoShareQualityTPCEntranceSepPairCut::Pass(const AliFemtoPair* pair){ + // Accept pairs based on their TPC entrance separation and + // quality and sharity + bool temp = true; + + double distx = pair->Track1()->Track()->NominalTpcEntrancePoint().x() - pair->Track2()->Track()->NominalTpcEntrancePoint().x(); + double disty = pair->Track1()->Track()->NominalTpcEntrancePoint().y() - pair->Track2()->Track()->NominalTpcEntrancePoint().y(); + double distz = pair->Track1()->Track()->NominalTpcEntrancePoint().z() - pair->Track2()->Track()->NominalTpcEntrancePoint().z(); + double dist = sqrt(distx*distx + disty*disty + distz*distz); + + temp = dist > fDTPCMin; + + if (temp) { + temp = AliFemtoShareQualityPairCut::Pass(pair); + } + else + fNPairsFailed++; + + return temp; +} +//__________________ +AliFemtoString AliFemtoShareQualityTPCEntranceSepPairCut::Report(){ + // Prepare a report from the execution + string stemp = "AliFemtoShareQualityTPCEntranceSep Pair Cut - remove shared and split pairs and pairs with small separation at the entrance to the TPC\n"; char ctemp[100]; + sprintf(ctemp,"Accept pair with TPC entrance separation more that %lf",fDTPCMin); + stemp += ctemp; + sprintf(ctemp,"Number of pairs which passed:\t%ld Number which failed:\t%ld\n",fNPairsPassed,fNPairsFailed); + stemp += ctemp; + AliFemtoString returnThis = stemp; + return returnThis;} +//__________________ + +TList *AliFemtoShareQualityTPCEntranceSepPairCut::ListSettings() +{ + // return a list of settings in a writable form + TList *tListSetttings = AliFemtoShareQualityPairCut::ListSettings(); + char buf[200]; + snprintf(buf, 200, "AliFemtoShareQualityTPCEntranceSepPairCut.tpcentsepmin=%lf", fDTPCMin); + tListSetttings->AddLast(new TObjString(buf)); + + return tListSetttings; +} + +void AliFemtoShareQualityTPCEntranceSepPairCut::SetTPCEntranceSepMinimum(double dtpc) +{ + fDTPCMin = dtpc; +} diff --git a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityTPCEntranceSepPairCut.h b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityTPCEntranceSepPairCut.h new file mode 100644 index 00000000000..e60dd2fcefd --- /dev/null +++ b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityTPCEntranceSepPairCut.h @@ -0,0 +1,58 @@ +///////////////////////////////////////////////////////////////////////////// +// // +// AliFemtoShareQualityTPCEntranceSepPairCut - a pair cut which checks // +// for some pair qualities that attempt to identify slit/doubly // +// reconstructed tracks and also selects pairs based on their separation // +// at the entrance to the TPC // +// // +///////////////////////////////////////////////////////////////////////////// +/*************************************************************************** + * + * $Id: AliFemtoShareQualityTPCEntranceSepPairCut.h,v 1.1.2.1 2007/10/19 13:35:33 akisiel Exp $ + * + * Author: Adam Kisiel, Ohio State University, kisiel@mps.ohio-state.edu + *************************************************************************** + * + * Description: part of STAR HBT Framework: AliFemtoMaker package + * a cut to remove "shared" and "split" pairs + * + *************************************************************************** + * + * + **************************************************************************/ + + +#ifndef ALIFEMTOSHAREQUALITYTPCENTRANCESEPPAIRCUT_H +#define ALIFEMTOSHAREQUALITYTPCENTRANCESEPPAIRCUT_H + +// do I need these lines ? +//#ifndef StMaker_H +//#include "StMaker.h" +//#endif + +#include "AliFemtoPairCut.h" +#include "AliFemtoShareQualityPairCut.h" + +class AliFemtoShareQualityTPCEntranceSepPairCut : public AliFemtoShareQualityPairCut{ +public: + AliFemtoShareQualityTPCEntranceSepPairCut(); + AliFemtoShareQualityTPCEntranceSepPairCut(const AliFemtoShareQualityTPCEntranceSepPairCut& c); + virtual ~AliFemtoShareQualityTPCEntranceSepPairCut(); + + virtual bool Pass(const AliFemtoPair* pair); + virtual AliFemtoString Report(); + virtual TList *ListSettings(); + virtual AliFemtoPairCut* Clone(); + void SetTPCEntranceSepMinimum(double dtpc); + + protected: + Double_t fDTPCMin; // Minimum allowed pair nominal separation at the entrance to the TPC + +#ifdef __ROOT__ + ClassDef(AliFemtoShareQualityTPCEntranceSepPairCut, 0) +#endif +}; + +inline AliFemtoPairCut* AliFemtoShareQualityTPCEntranceSepPairCut::Clone() { AliFemtoShareQualityTPCEntranceSepPairCut* c = new AliFemtoShareQualityTPCEntranceSepPairCut(*this); return c;} + +#endif diff --git a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoTPCInnerCorrFctn.cxx b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoTPCInnerCorrFctn.cxx new file mode 100644 index 00000000000..57bfd81852b --- /dev/null +++ b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoTPCInnerCorrFctn.cxx @@ -0,0 +1,141 @@ +//////////////////////////////////////////////////////////////////////////////// +/// /// +/// AliFemtoTPCInnerCorrFctn - A correlation function that saves the /// +/// distance at the entrance to the TPC between two tracks as a function /// +/// of qinv /// +/// Authors: Adam Kisiel kisiel@mps.ohio-state.edu /// +/// /// +//////////////////////////////////////////////////////////////////////////////// + +#include "AliFemtoTPCInnerCorrFctn.h" +//#include "AliFemtoHisto.hh" +#include + +#ifdef __ROOT__ +ClassImp(AliFemtoTPCInnerCorrFctn) +#endif + +//____________________________ +AliFemtoTPCInnerCorrFctn::AliFemtoTPCInnerCorrFctn(char* title, const int& nbins, const float& QinvLo, const float& QinvHi): + fDTPCNumerator(0), + fDTPCDenominator(0) +{ + // set up numerator + // title = "Num Qinv (MeV/c)"; + char tTitNum[100] = "NumDTPC"; + strcat(tTitNum,title); + fDTPCNumerator = new TH2D(tTitNum,title,nbins,QinvLo,QinvHi,100,0.0,20.0); + // set up denominator + //title = "Den Qinv (MeV/c)"; + char tTitDen[100] = "DenDTPC"; + strcat(tTitDen,title); + fDTPCDenominator = new TH2D(tTitDen,title,nbins,QinvLo,QinvHi,100,0.0,20.0); + + // to enable error bar calculation... + fDTPCNumerator->Sumw2(); + fDTPCDenominator->Sumw2(); +} + +//____________________________ +AliFemtoTPCInnerCorrFctn::AliFemtoTPCInnerCorrFctn(const AliFemtoTPCInnerCorrFctn& aCorrFctn) : + fDTPCNumerator(0), + fDTPCDenominator(0) +{ + // copy constructor + if (aCorrFctn.fDTPCNumerator) + fDTPCNumerator = new TH2D(*aCorrFctn.fDTPCNumerator); + if (aCorrFctn.fDTPCDenominator) + fDTPCDenominator = new TH2D(*aCorrFctn.fDTPCDenominator); +} +//____________________________ +AliFemtoTPCInnerCorrFctn::~AliFemtoTPCInnerCorrFctn(){ + // destructor + delete fDTPCNumerator; + delete fDTPCDenominator; +} +//_________________________ +AliFemtoTPCInnerCorrFctn& AliFemtoTPCInnerCorrFctn::operator=(const AliFemtoTPCInnerCorrFctn& aCorrFctn) +{ + // assignment operator + if (this == &aCorrFctn) + return *this; + + if (aCorrFctn.fDTPCNumerator) + fDTPCNumerator = new TH2D(*aCorrFctn.fDTPCNumerator); + else + fDTPCNumerator = 0; + if (aCorrFctn.fDTPCDenominator) + fDTPCDenominator = new TH2D(*aCorrFctn.fDTPCDenominator); + else + fDTPCDenominator = 0; + + return *this; +} +//_________________________ +void AliFemtoTPCInnerCorrFctn::Finish(){ + // here is where we should normalize, fit, etc... + // we should NOT Draw() the histos (as I had done it below), + // since we want to insulate ourselves from root at this level + // of the code. Do it instead at root command line with browser. + // mShareNumerator->Draw(); + //mShareDenominator->Draw(); + //mRatio->Draw(); + +} + +//____________________________ +AliFemtoString AliFemtoTPCInnerCorrFctn::Report(){ + // create report + string stemp = "Entrace TPC distance Correlation Function Report:\n"; + char ctemp[100]; + sprintf(ctemp,"Number of entries in numerator:\t%E\n",fDTPCNumerator->GetEntries()); + stemp += ctemp; + sprintf(ctemp,"Number of entries in denominator:\t%E\n",fDTPCDenominator->GetEntries()); + stemp += ctemp; + // stemp += mCoulombWeight->Report(); + AliFemtoString returnThis = stemp; + return returnThis; +} +//____________________________ +void AliFemtoTPCInnerCorrFctn::AddRealPair( AliFemtoPair* pair){ + // add real (effect) pair + double tQinv = fabs(pair->QInv()); // note - qInv() will be negative for identical pairs... + double distx = pair->Track1()->Track()->NominalTpcEntrancePoint().x() - pair->Track2()->Track()->NominalTpcEntrancePoint().x(); + double disty = pair->Track1()->Track()->NominalTpcEntrancePoint().y() - pair->Track2()->Track()->NominalTpcEntrancePoint().y(); + double distz = pair->Track1()->Track()->NominalTpcEntrancePoint().z() - pair->Track2()->Track()->NominalTpcEntrancePoint().z(); + double dist = sqrt(distx*distx + disty*disty + distz*distz); + + fDTPCNumerator->Fill(tQinv, dist); +// cout << "AliFemtoTPCInnerCorrFctn::AddRealPair : " << tQinv << " " << dist << endl; +// cout << distx << " " << disty << " " << distz << endl; +} +//____________________________ +void AliFemtoTPCInnerCorrFctn::AddMixedPair( AliFemtoPair* pair){ + // add mixed (background) pair + double tQinv = fabs(pair->QInv()); // note - qInv() will be negative for identical pairs... + double distx = pair->Track1()->Track()->NominalTpcEntrancePoint().x() - pair->Track2()->Track()->NominalTpcEntrancePoint().x(); + double disty = pair->Track1()->Track()->NominalTpcEntrancePoint().y() - pair->Track2()->Track()->NominalTpcEntrancePoint().y(); + double distz = pair->Track1()->Track()->NominalTpcEntrancePoint().z() - pair->Track2()->Track()->NominalTpcEntrancePoint().z(); + double dist = sqrt(distx*distx + disty*disty + distz*distz); + + fDTPCDenominator->Fill(tQinv,dist); +} + + +void AliFemtoTPCInnerCorrFctn::WriteHistos() +{ + // Write out result histograms + fDTPCNumerator->Write(); + fDTPCDenominator->Write(); +} +//______________________________ +TList* AliFemtoTPCInnerCorrFctn::GetOutputList() +{ + // Prepare the list of objects to be written to the output + TList *tOutputList = new TList(); + + tOutputList->Add(fDTPCNumerator); + tOutputList->Add(fDTPCDenominator); + + return tOutputList; +} diff --git a/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoTPCInnerCorrFctn.h b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoTPCInnerCorrFctn.h new file mode 100644 index 00000000000..da4ebd2c03f --- /dev/null +++ b/PWG2/FEMTOSCOPY/AliFemtoUser/AliFemtoTPCInnerCorrFctn.h @@ -0,0 +1,45 @@ +//////////////////////////////////////////////////////////////////////////////// +/// /// +/// AliFemtoTPCInnerCorrFctn - A correlation function that saves the /// +/// distance at the entrance to the TPC between two tracks as a function /// +/// of qinv /// +/// Authors: Adam Kisiel kisiel@mps.ohio-state.edu /// +/// /// +//////////////////////////////////////////////////////////////////////////////// + +#ifndef AliFemtoTPCInnerCorrFctn_hh +#define AliFemtoTPCInnerCorrFctn_hh + +#include "TH1D.h" +#include "TH2D.h" +#include "AliFemtoCorrFctn.h" + +class AliFemtoTPCInnerCorrFctn : public AliFemtoCorrFctn { +public: + AliFemtoTPCInnerCorrFctn(char* title, const int& nbins, const float& QinvLo, const float& QinvHi); + AliFemtoTPCInnerCorrFctn(const AliFemtoTPCInnerCorrFctn& aCorrFctn); + virtual ~AliFemtoTPCInnerCorrFctn(); + + AliFemtoTPCInnerCorrFctn& operator=(const AliFemtoTPCInnerCorrFctn& aCorrFctn); + + virtual AliFemtoString Report(); + virtual void AddRealPair(AliFemtoPair* aPair); + virtual void AddMixedPair(AliFemtoPair* aPair); + + virtual void Finish(); + + void WriteHistos(); + virtual TList* GetOutputList(); +private: + + TH2D *fDTPCNumerator; // Distance at the entrance to the TPC for real pairs + TH2D *fDTPCDenominator; // Distance at the entrance to tht TPC for mixed pairs + +#ifdef __ROOT__ + ClassDef(AliFemtoTPCInnerCorrFctn, 1) +#endif +}; + + +#endif + diff --git a/PWG2/PWG2femtoscopyLinkDef.h b/PWG2/PWG2femtoscopyLinkDef.h index 471c9cee1da..424607296b7 100644 --- a/PWG2/PWG2femtoscopyLinkDef.h +++ b/PWG2/PWG2femtoscopyLinkDef.h @@ -7,12 +7,14 @@ #pragma link C++ class AliFemtoEventReader; #pragma link C++ class AliFemtoKinkCut; #pragma link C++ class AliFemtoPairCut; +#pragma link C++ class AliFemtoKTPairCut; #pragma link C++ class AliFemtoParticleCut; #pragma link C++ class AliFemtoTrackCut; #pragma link C++ class AliFemtoV0Cut; #pragma link C++ class AliFemtoXiCut; #pragma link C++ class AliFemtoBPLCMS3DCorrFctn; #pragma link C++ class AliFemtoQinvCorrFctn; +#pragma link C++ class AliFemtoCorrFctnNonIdDR; #pragma link C++ class AliFemtoBasicEventCut; #pragma link C++ class AliFemtoBasicTrackCut; #pragma link C++ class AliFemtoDummyPairCut; @@ -27,6 +29,7 @@ #pragma link C++ class AliFmThreeVectorF; #pragma link C++ class AliFemtoEventReaderESD; #pragma link C++ class AliFemtoEventReaderESDChain; +#pragma link C++ class AliFemtoEventReaderESDChainKine; #pragma link C++ class AliFemtoModelManager; #pragma link C++ class AliFemtoModelWeightGenerator; #pragma link C++ class AliFemtoModelWeightGeneratorBasic; @@ -35,3 +38,4 @@ #pragma link C++ class AliFemtoModelHiddenInfo; #pragma link C++ class AliFemtoModelCorrFctn; #pragma link C++ class AliFemtoModelWeightGeneratorLednicky; +#pragma link C++ class AliFemtoCutMonitorParticleYPt; diff --git a/PWG2/PWG2femtoscopyUserLinkDef.h b/PWG2/PWG2femtoscopyUserLinkDef.h index dcb309295a7..68ec128f81c 100644 --- a/PWG2/PWG2femtoscopyUserLinkDef.h +++ b/PWG2/PWG2femtoscopyUserLinkDef.h @@ -14,13 +14,20 @@ // #pragma link C++ class marekTrackCut; // #pragma link C++ class marekPairCut; #pragma link C++ class AliFemtoShareQualityPairCut; +#pragma link C++ class AliFemtoShareQualityKTPairCut; +#pragma link C++ class AliFemtoShareQualityTPCEntranceSepPairCut; #pragma link C++ class AliFemtoESDTrackCut; #pragma link C++ class AliFemtoQPairCut; #pragma link C++ class AliFemtoShareQualityCorrFctn; +#pragma link C++ class AliFemtoTPCInnerCorrFctn; +#pragma link C++ class AliFemtoChi2CorrFctn; #pragma link C++ class AliFemtoModelCorrFctnSource; +#pragma link C++ class AliFemtoModelBPLCMSCorrFctn; #pragma link C++ class AliFemtoModelGausRinvFreezeOutGenerator; //#pragma link C++ class AliStHbtEvent; //#pragma link C++ class AliStHbtEventReader; //#pragma link C++ class AliStHbtPythiaOnFlyEventReader; //#pragma link C++ class AliStHbtTrack; #pragma link C++ class AliFemtoEventReaderESDKine; +#pragma link C++ class AliFemtoModelCorrFctnTrueQ; +#pragma link C++ class AliFemtoCutMonitorParticleMomRes; diff --git a/PWG2/libPWG2femtoscopy.pkg b/PWG2/libPWG2femtoscopy.pkg index bf153a9cffa..07ae089481f 100644 --- a/PWG2/libPWG2femtoscopy.pkg +++ b/PWG2/libPWG2femtoscopy.pkg @@ -25,6 +25,7 @@ SRCS= FEMTOSCOPY/AliFemto/AliFemtoSimpleAnalysis.cxx \ FEMTOSCOPY/AliFemto/AliFemtoEventReader.cxx \ FEMTOSCOPY/AliFemto/AliFemtoEventReaderESD.cxx \ FEMTOSCOPY/AliFemto/AliFemtoEventReaderESDChain.cxx \ + FEMTOSCOPY/AliFemto/AliFemtoEventReaderESDChainKine.cxx \ FEMTOSCOPY/AliFemto/AliFemtoModelHiddenInfo.cxx \ FEMTOSCOPY/AliFemto/AliFemtoModelGausLCMSFreezeOutGenerator.cxx \ FEMTOSCOPY/AliFemto/AliFemtoModelWeightGenerator.cxx \ @@ -32,7 +33,11 @@ SRCS= FEMTOSCOPY/AliFemto/AliFemtoSimpleAnalysis.cxx \ FEMTOSCOPY/AliFemto/AliFemtoModelManager.cxx \ FEMTOSCOPY/AliFemto/AliFemtoModelCorrFctn.cxx \ FEMTOSCOPY/AliFemto/AliFemtoModelFreezeOutGenerator.cxx \ - FEMTOSCOPY/AliFemto/AliFemtoModelWeightGeneratorLednicky.cxx + FEMTOSCOPY/AliFemto/AliFemtoModelWeightGeneratorLednicky.cxx \ + FEMTOSCOPY/AliFemto/AliFemtoCutMonitorParticleYPt.cxx \ + FEMTOSCOPY/AliFemto/AliFemtoKTPairCut.cxx \ + FEMTOSCOPY/AliFemto/AliFemtoCorrFctnNonIdDR.cxx + HDRS= $(SRCS:.cxx=.h) HDRS += FEMTOSCOPY/AliFemto/AliFmThreeVector.h \ diff --git a/PWG2/libPWG2femtoscopyUser.pkg b/PWG2/libPWG2femtoscopyUser.pkg index be6f00193b3..6419d3f3a35 100644 --- a/PWG2/libPWG2femtoscopyUser.pkg +++ b/PWG2/libPWG2femtoscopyUser.pkg @@ -1,10 +1,17 @@ SRCS= FEMTOSCOPY/AliFemtoUser/AliFemtoQPairCut.cxx \ FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityPairCut.cxx \ + FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityKTPairCut.cxx \ + FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityTPCEntranceSepPairCut.cxx \ FEMTOSCOPY/AliFemtoUser/AliFemtoESDTrackCut.cxx \ FEMTOSCOPY/AliFemtoUser/AliFemtoShareQualityCorrFctn.cxx \ + FEMTOSCOPY/AliFemtoUser/AliFemtoTPCInnerCorrFctn.cxx \ + FEMTOSCOPY/AliFemtoUser/AliFemtoChi2CorrFctn.cxx \ FEMTOSCOPY/AliFemtoUser/AliFemtoModelCorrFctnSource.cxx \ + FEMTOSCOPY/AliFemtoUser/AliFemtoModelBPLCMSCorrFctn.cxx \ FEMTOSCOPY/AliFemtoUser/AliFemtoModelGausRinvFreezeOutGenerator.cxx \ - FEMTOSCOPY/AliFemtoUser/AliFemtoEventReaderESDKine.cxx + FEMTOSCOPY/AliFemtoUser/AliFemtoEventReaderESDKine.cxx \ + FEMTOSCOPY/AliFemtoUser/AliFemtoModelCorrFctnTrueQ.cxx \ + FEMTOSCOPY/AliFemtoUser/AliFemtoCutMonitorParticleMomRes.cxx HDRS= $(SRCS:.cxx=.h) -- 2.43.5