--- /dev/null
+////////////////////////////////////////////////////////////////////////////////
+/// ///
+/// AliFemtoModelCorrFctn - the base class for correlation function which ///
+/// uses the model framework and weight generation ///
+/// ///
+////////////////////////////////////////////////////////////////////////////////
+#ifdef __ROOT__
+ ClassImp(AliFemtoModelCorrFctn, 1)
+#endif
+
+#include "AliFemtoModelGausLCMSFreezeOutGenerator.h"
+#include "AliFemtoModelHiddenInfo.h"
+#include "AliFemtoModelCorrFctn.h"
+
+//_______________________
+AliFemtoModelCorrFctn::AliFemtoModelCorrFctn():
+ fManager(0),
+ fNumeratorTrue(0),
+ fNumeratorFake(0),
+ fDenominator(0)
+{
+ fNumeratorTrue = new TH1D("ModelNumTrue","ModelNumTrue",50,0.0,0.5);
+ fNumeratorFake = new TH1D("ModelNumFake","ModelNumFake",50,0.0,0.5);
+ fDenominator = new TH1D("ModelDen","ModelDen",50,0.0,0.5);
+
+ fNumeratorTrue->Sumw2();
+ fNumeratorFake->Sumw2();
+ fDenominator->Sumw2();
+}
+//_______________________
+AliFemtoModelCorrFctn::AliFemtoModelCorrFctn(const char *title, Int_t aNbins, Double_t aQinvLo, Double_t aQinvHi):
+ fManager(0),
+ fNumeratorTrue(0),
+ fNumeratorFake(0),
+ fDenominator(0)
+{
+ char buf[100];
+ sprintf(buf, "NumTrue%s", title);
+ fNumeratorTrue = new TH1D(buf,buf,aNbins,aQinvLo,aQinvHi);
+ sprintf(buf, "NumFake%s", title);
+ fNumeratorFake = new TH1D(buf,buf,aNbins,aQinvLo,aQinvHi);
+ sprintf(buf, "Den%s", title);
+ fDenominator = new TH1D(buf,buf,aNbins,aQinvLo,aQinvHi);
+
+ fNumeratorTrue->Sumw2();
+ fNumeratorFake->Sumw2();
+ fDenominator->Sumw2();
+}
+//_______________________
+AliFemtoModelCorrFctn::AliFemtoModelCorrFctn(const AliFemtoModelCorrFctn& aCorrFctn) :
+ fManager(0),
+ fNumeratorTrue(0),
+ fNumeratorFake(0),
+ fDenominator(0)
+{
+ if (aCorrFctn.fNumeratorTrue)
+ fNumeratorTrue = new TH1D(*(aCorrFctn.fNumeratorTrue));
+ if (aCorrFctn.fNumeratorFake)
+ fNumeratorFake = new TH1D(*(aCorrFctn.fNumeratorFake));
+ if (aCorrFctn.fDenominator)
+ fDenominator = new TH1D(*(aCorrFctn.fDenominator));
+ fManager = aCorrFctn.fManager;
+}
+//_______________________
+AliFemtoModelCorrFctn::~AliFemtoModelCorrFctn()
+{
+ if (fNumeratorTrue) delete fNumeratorTrue;
+ if (fNumeratorFake) delete fNumeratorFake;
+ if (fDenominator) delete fDenominator;
+}
+//_______________________
+AliFemtoModelCorrFctn& AliFemtoModelCorrFctn::operator=(const AliFemtoModelCorrFctn& aCorrFctn)
+{
+ if (this == &aCorrFctn)
+ return *this;
+
+ if (aCorrFctn.fNumeratorTrue)
+ fNumeratorTrue = new TH1D(*(aCorrFctn.fNumeratorTrue));
+ else
+ fNumeratorTrue = 0;
+ if (aCorrFctn.fNumeratorFake)
+ fNumeratorFake = new TH1D(*(aCorrFctn.fNumeratorFake));
+ else
+ fNumeratorFake = 0;
+ if (aCorrFctn.fDenominator)
+ fDenominator = new TH1D(*(aCorrFctn.fDenominator));
+ else
+ fDenominator = 0;
+ fManager = aCorrFctn.fManager;
+
+ return *this;
+}
+//_______________________
+void AliFemtoModelCorrFctn::ConnectToManager(AliFemtoModelManager *aManager)
+{
+ fManager = aManager;
+}
+
+//_______________________
+AliFemtoString AliFemtoModelCorrFctn::Report()
+{
+ AliFemtoString tStr = "AliFemtoModelCorrFctn report";
+
+ return tStr;
+}
+
+//_______________________
+void AliFemtoModelCorrFctn::AddRealPair(AliFemtoPair* aPair)
+{
+ Double_t weight = fManager->GetWeight(aPair);
+ fNumeratorTrue->Fill(aPair->qInv(), weight);
+}
+//_______________________
+void AliFemtoModelCorrFctn::AddMixedPair(AliFemtoPair* aPair)
+{
+ Double_t weight = fManager->GetWeight(aPair);
+ fNumeratorFake->Fill(aPair->qInv(), weight);
+ fDenominator->Fill(aPair->qInv(), 1.0);
+}
+//_______________________
+void AliFemtoModelCorrFctn::EventBegin(const AliFemtoEvent* aEvent)
+{
+ /* Do nothing */
+}
+//_______________________
+void AliFemtoModelCorrFctn::EventEnd(const AliFemtoEvent* aEvent)
+{
+ /* Do nothing */
+}
+//_______________________
+void AliFemtoModelCorrFctn::Finish()
+{
+ /* Do nothing */
+}
+//_______________________
+void AliFemtoModelCorrFctn::Write()
+{
+ fNumeratorTrue->Write();
+ fNumeratorFake->Write();
+ fDenominator->Write();
+}
+//_______________________
+AliFemtoModelCorrFctn* AliFemtoModelCorrFctn::Clone()
+{
+ AliFemtoModelCorrFctn *tCopy = new AliFemtoModelCorrFctn(*this);
+
+ return tCopy;
+}
+
--- /dev/null
+////////////////////////////////////////////////////////////////////////////////
+/// ///
+/// AliFemtoModelCorrFctn - the base class for correlation function which ///
+/// uses the model framework and weight generation ///
+/// ///
+////////////////////////////////////////////////////////////////////////////////
+#ifndef AliFemtoModelCorrFctn_hh
+#define AliFemtoModelCorrFctn_hh
+
+#include "Base/AliFemtoCorrFctn.h"
+#include "Infrastructure/AliFemtoPair.h"
+#include "AliFemtoModelManager.h"
+
+class AliFemtoModelCorrFctn: public AliFemtoCorrFctn {
+
+public:
+ AliFemtoModelCorrFctn();
+ AliFemtoModelCorrFctn(const char *title, Int_t aNbins, Double_t aQinvLo, Double_t aQinvHi);
+ AliFemtoModelCorrFctn(const AliFemtoModelCorrFctn& aCorrFctn);
+ virtual ~AliFemtoModelCorrFctn();
+
+ AliFemtoModelCorrFctn& operator=(const AliFemtoModelCorrFctn& aCorrFctn);
+
+ virtual void ConnectToManager(AliFemtoModelManager *aManager);
+
+ virtual AliFemtoString Report();
+
+ virtual void AddRealPair(AliFemtoPair* aPair);
+ virtual void AddMixedPair(AliFemtoPair* aPir);
+
+ virtual void EventBegin(const AliFemtoEvent* aEvent);
+ virtual void EventEnd(const AliFemtoEvent* aEvent);
+ virtual void Finish();
+
+ virtual void Write();
+
+ virtual AliFemtoModelCorrFctn* Clone();
+
+ AliFemtoBaseAnalysis* HbtAnalysis(){return fyAnalysis;};
+ void SetAnalysis(AliFemtoBaseAnalysis* aAnalysis);
+
+protected:
+ AliFemtoModelManager *fManager; // Link back to the managet 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)
+ TH1D *fDenominator; // Denominator made with mixed pairs
+
+private:
+
+#ifdef __ROOT__
+ ClassDef(AliFemtoModelCorrFctn, 1)
+#endif
+};
+
+#endif
--- /dev/null
+////////////////////////////////////////////////////////////////////////////////
+/// ///
+/// AliFemtoModelFreezeOutGenerator - abstract base class for freeze-out ///
+/// coordinates generator ///
+/// Authors: Adam Kisiel kisiel@mps.ohio-state.edu ///
+/// ///
+////////////////////////////////////////////////////////////////////////////////
+#ifndef AliFemtoModelFreezeOutGenerator_hh
+#define AliFemtoModelFreezeOutGenerator_hh
+
+#include "TRandom2.h"
+#include "AliFemtoPair.h"
+
+class AliFemtoModelFreezeOutGenerator
+{
+ public:
+ AliFemtoModelFreezeOutGenerator();
+ AliFemtoModelFreezeOutGenerator(AliFemtoModelFreezeOutGenerator &aModel);
+
+ AliFemtoModelFreezeOutGenerator& operator=(const AliFemtoModelFreezeOutGenerator& aGen);
+
+ virtual ~AliFemtoModelFreezeOutGenerator();
+ virtual void GenerateFreezeOut(AliFemtoPair *aPair) = 0;
+
+ virtual AliFemtoModelFreezeOutGenerator* Clone() const;
+
+ protected:
+ TRandom2 *fRandom;
+
+ private:
+
+#ifdef __ROOT__
+ ClassDef(AliFemtoModelFreezeOutGenerator, 1)
+#endif
+
+};
+
+inline AliFemtoModelFreezeOutGenerator::AliFemtoModelFreezeOutGenerator(): fRandom(0) { /* no-op */ };
+inline AliFemtoModelFreezeOutGenerator::AliFemtoModelFreezeOutGenerator(AliFemtoModelFreezeOutGenerator &aModel): fRandom(0){/* no-op */};
+inline AliFemtoModelFreezeOutGenerator& AliFemtoModelFreezeOutGenerator::operator=(const AliFemtoModelFreezeOutGenerator& aGen)
+{
+ if (this == &aGen) return *this;
+ if (aGen.fRandom)
+ fRandom = new TRandom2(*aGen.fRandom);
+ else
+ fRandom=0;
+ return *this;
+};
+
+inline AliFemtoModelFreezeOutGenerator::AliFemtoModelFreezeOutGenerator* Clone() { return 0; };
+
+
+#endif
+
+
--- /dev/null
+////////////////////////////////////////////////////////////////////////////////
+/// ///
+/// AliFemtoModelGausLCMSFreezeOutGenerator - freeze-out ///
+/// coordinates generator, generating a 3D gaussian ellipsoid in LCMS ///
+/// Authors: Adam Kisiel kisiel@mps.ohio-state.edu ///
+/// ///
+////////////////////////////////////////////////////////////////////////////////
+#ifdef __ROOT__
+ ClassImp(AliFemtoModelGausLCMSFreezeOutGenerator, 1)
+#endif
+
+#include "math.h"
+#include "AliFemtoModelGausLCMSFreezeOutGenerator.h"
+#include "AliFemtoModelHiddenInfo.h"
+#include "AliFemtoLorentzVector.h"
+
+//_______________________
+AliFemtoModelGausLCMSFreezeOutGenerator::AliFemtoModelGausLCMSFreezeOutGenerator() :
+ fSizeOut(0), fSizeSide(0), fSizeLong(0)
+{
+ // Default constructor
+ fRandom = new TRandom2();
+}
+
+//_______________________
+AliFemtoModelGausLCMSFreezeOutGenerator::AliFemtoModelGausLCMSFreezeOutGenerator(const AliFemtoModelGausLCMSFreezeOutGenerator &aModel):
+ fSizeOut(0), fSizeSide(0), fSizeLong(0)
+{
+ // Copy constructor
+ fRandom = new TRandom2();
+ SetSizeOut(aModel.GetSizeOut());
+ SetSizeSide(aModel.GetSizeSide());
+ SetSizeLong(aModel.GetSizeLong());
+}
+//_______________________
+AliFemtoModelGausLCMSFreezeOutGenerator::~AliFemtoModelGausLCMSFreezeOutGenerator()
+{
+ if (fRandom) delete fRandom;
+}
+//_______________________
+void AliFemtoModelGausLCMSFreezeOutGenerator::GenerateFreezeOut(AliFemtoPair *aPair)
+{
+ // Generate two particle emission points with respect
+ // to their pair momentum
+ // The source is the 3D Gaussian ellipsoid in the LCMS frame
+ AliFemtoModelHiddenInfo *inf1 = (AliFemtoModelHiddenInfo *) aPair->track1()->HiddenInfo();
+ AliFemtoModelHiddenInfo *inf2 = (AliFemtoModelHiddenInfo *) aPair->track2()->HiddenInfo();
+
+ if ((!inf1) || (!inf2)) { cout << "Hidden info not created! " << endl; exit(kFALSE); }
+
+ Double_t tPx = inf1->GetTrueMomentum()->x() + inf2->GetTrueMomentum()->x();
+ Double_t tPy = inf1->GetTrueMomentum()->y() + inf2->GetTrueMomentum()->y();
+ Double_t tPz = inf1->GetTrueMomentum()->z() + inf2->GetTrueMomentum()->z();
+ Double_t tM1 = inf1->GetMass();
+ Double_t tM2 = inf2->GetMass();
+ Double_t tE1 = sqrt(tM1*tM1 + inf1->GetTrueMomentum()->mag2());
+ Double_t tE2 = sqrt(tM2*tM2 + inf2->GetTrueMomentum()->mag2());
+ Double_t tEs = tE1 + tE2;
+
+ Double_t tPt = sqrt(tPx*tPx + tPy*tPy);
+
+ Double_t tRout = fRandom->Gaus(0.0, fSizeOut);
+ Double_t tRside = fRandom->Gaus(0.0, fSizeSide);
+ Double_t tRlong = fRandom->Gaus(0.0, fSizeLong);
+
+ Double_t tXout = (tPx * tRout + tPy * tRside)/tPt;
+ Double_t tXside = (tPy * tRout - tPx * tRside)/tPt;
+
+ Double_t tBetaz = tPz/tEs;
+ Double_t tGammaz = 1.0/(1-tBetaz*tBetaz);
+
+ Double_t tXlong = tGammaz * (tRlong + tBetaz * 0);
+ Double_t tXtime = tGammaz * (0 + tBetaz * tRlong);
+
+ if (!(inf1->GetEmissionPoint())) {
+ AliFemtoLorentzVector *tPos = new AliFemtoLorentzVector(0,0,0,0);
+ inf1->SetEmissionPoint(tPos);
+ }
+ else
+ inf1->SetEmissionPoint(0,0,0,0);
+ if (!(inf2->GetEmissionPoint())) {
+ AliFemtoLorentzVector *tPos = new AliFemtoLorentzVector(tXout,tXside,tXlong,tXtime);
+ inf2->SetEmissionPoint(tPos);
+ }
+ else
+ inf2->SetEmissionPoint(tXout, tXside, tXlong, tXtime);
+}
+
+//_______________________
+void AliFemtoModelGausLCMSFreezeOutGenerator::SetSizeOut(Double_t aSizeOut)
+{
+ fSizeOut = aSizeOut;
+}
+//_______________________
+void AliFemtoModelGausLCMSFreezeOutGenerator::SetSizeSide(Double_t aSizeSide)
+{
+ fSizeSide = aSizeSide;
+}
+//_______________________
+void AliFemtoModelGausLCMSFreezeOutGenerator::SetSizeLong(Double_t aSizeLong)
+{
+ fSizeLong = aSizeLong;
+}
+
+//_______________________
+Double_t AliFemtoModelGausLCMSFreezeOutGenerator::GetSizeOut() const
+{
+ return fSizeOut;
+}
+//_______________________
+Double_t AliFemtoModelGausLCMSFreezeOutGenerator::GetSizeSide() const
+{
+ return fSizeSide;
+}
+//_______________________
+Double_t AliFemtoModelGausLCMSFreezeOutGenerator::GetSizeLong() const
+{
+ return fSizeLong;
+}
+//_______________________
+AliFemtoModelFreezeOutGenerator* AliFemtoModelGausLCMSFreezeOutGenerator::Clone() const
+{
+ return GetGenerator();
+}
+//_______________________
+AliFemtoModelFreezeOutGenerator* AliFemtoModelGausLCMSFreezeOutGenerator::GetGenerator() const
+{
+ AliFemtoModelFreezeOutGenerator* tModel = new AliFemtoModelGausLCMSFreezeOutGenerator(*this); return tModel;
+}
--- /dev/null
+////////////////////////////////////////////////////////////////////////////////
+/// ///
+/// AliFemtoModelGausLCMSFreezeOutGenerator - freeze-out ///
+/// coordinates generator, generating a 3D gaussian ellipsoid in LCMS ///
+/// Authors: Adam Kisiel kisiel@mps.ohio-state.edu ///
+/// ///
+////////////////////////////////////////////////////////////////////////////////
+#ifndef AliFemtoModelGausLCMSFreezeOutGenerator_hh
+#define AliFemtoModelGausLCMSFreezeOutGenerator_hh
+
+#include "Model/AliFemtoModelFreezeOutGenerator.h"
+
+#include "TRandom.h"
+
+class AliFemtoModelGausLCMSFreezeOutGenerator : public AliFemtoModelFreezeOutGenerator
+{
+ public:
+ AliFemtoModelGausLCMSFreezeOutGenerator();
+ AliFemtoModelGausLCMSFreezeOutGenerator(const AliFemtoModelGausLCMSFreezeOutGenerator &aModel);
+ virtual ~AliFemtoModelGausLCMSFreezeOutGenerator();
+ virtual void GenerateFreezeOut(AliFemtoPair *aPair);;
+
+ void SetSizeOut(Double_t aSizeOut);
+ void SetSizeSide(Double_t aSizeSide);
+ void SetSizeLong(Double_t aSizeLong);
+
+ Double_t GetSizeOut() const;
+ Double_t GetSizeSide() const;
+ Double_t GetSizeLong() const;
+
+ virtual AliFemtoModelFreezeOutGenerator* Clone() const;
+
+ protected:
+ Double_t fSizeOut;
+ Double_t fSizeSide;
+ Double_t fSizeLong;
+
+ private:
+ AliFemtoModelFreezeOutGenerator* GetGenerator() const;
+
+#ifdef __ROOT__
+ ClassDef(AliFemtoModelGausLCMSFreezeOutGenerator, 1)
+#endif
+
+ };
+
+#endif
+
+
--- /dev/null
+#include "AliFemtoModelHiddenInfo.h"
+
+//_____________________________________________
+AliFemtoModelHiddenInfo::AliFemtoModelHiddenInfo() :
+ fTrueMomentum(0),
+ fEmissionPoint(0),
+ fPDGPid(0),
+ fMass(0)
+{
+};
+//_____________________________________________
+AliFemtoModelHiddenInfo::AliFemtoModelHiddenInfo(const AliFemtoModelHiddenInfo &aInfo) :
+ fTrueMomentum(0),
+ fEmissionPoint(0),
+ fPDGPid(0),
+ fMass(0)
+{
+ if (aInfo.GetTrueMomentum())
+ SetTrueMomentum(aInfo.GetTrueMomentum());
+ if (aInfo.GetEmissionPoint())
+ SetEmissionPoint(aInfo.GetEmissionPoint());
+ fPDGPid = aInfo.GetPDGPid();
+ fMass = aInfo.GetMass();
+}
+//_____________________________________________
+AliFemtoModelHiddenInfo::~AliFemtoModelHiddenInfo()
+{
+ if (fTrueMomentum) delete fTrueMomentum;
+ if (fEmissionPoint) delete fEmissionPoint;
+}
+//_____________________________________________
+AliFemtoModelHiddenInfo& AliFemtoModelHiddenInfo::operator=(const AliFemtoModelHiddenInfo& aInfo)
+{
+ if (this == &aInfo)
+ return *this;
+
+ if (aInfo.GetTrueMomentum())
+ SetTrueMomentum(aInfo.GetTrueMomentum());
+ else SetTrueMomentum(0);
+ if (aInfo.GetEmissionPoint())
+ SetEmissionPoint(aInfo.GetEmissionPoint());
+ else SetEmissionPoint(0);
+ fPDGPid = aInfo.GetPDGPid();
+ fMass = aInfo.GetMass();
+
+ return *this;
+}
+//_____________________________________________
+AliFemtoThreeVector *AliFemtoModelHiddenInfo::GetTrueMomentum() const
+{
+ return fTrueMomentum;
+}
+//_____________________________________________
+AliFemtoLorentzVector *AliFemtoModelHiddenInfo::GetEmissionPoint() const
+{
+ return fEmissionPoint;
+}
+//_____________________________________________
+Int_t AliFemtoModelHiddenInfo::GetPDGPid() const
+{
+ return fPDGPid;
+}
+//_____________________________________________
+Double_t AliFemtoModelHiddenInfo::GetMass() const
+{
+ return fMass;
+}
+//_____________________________________________
+void AliFemtoModelHiddenInfo::SetTrueMomentum(AliFemtoThreeVector *aMom)
+{
+ if (fTrueMomentum) {
+ fTrueMomentum->setX(aMom->x());
+ fTrueMomentum->setY(aMom->y());
+ fTrueMomentum->setZ(aMom->z());
+ }
+ else {
+ fTrueMomentum = new AliFemtoThreeVector(*aMom);
+ }
+}
+//_____________________________________________
+void AliFemtoModelHiddenInfo::SetTrueMomentum(const AliFemtoThreeVector& aMom)
+{
+ if (fTrueMomentum) {
+ fTrueMomentum->setX(aMom.x());
+ fTrueMomentum->setY(aMom.y());
+ fTrueMomentum->setZ(aMom.z());
+ }
+ else {
+ fTrueMomentum = new AliFemtoThreeVector();
+ *fTrueMomentum = aMom;
+ }
+}
+//_____________________________________________
+void AliFemtoModelHiddenInfo::SetTrueMomentum(Double_t aPx, Double_t aPy, Double_t aPz)
+{
+ if (!fTrueMomentum) fTrueMomentum = new AliFemtoThreeVector();
+ fTrueMomentum->setX(aPx);
+ fTrueMomentum->setY(aPy);
+ fTrueMomentum->setZ(aPz);
+}
+//_____________________________________________
+void AliFemtoModelHiddenInfo::SetEmissionPoint(AliFemtoLorentzVector *aPos)
+{
+ if (fEmissionPoint) {
+ fEmissionPoint->setX(aPos->px());
+ fEmissionPoint->setY(aPos->py());
+ fEmissionPoint->setZ(aPos->pz());
+ fEmissionPoint->setT(aPos->e());
+ }
+ else {
+ fEmissionPoint = new AliFemtoLorentzVector(*aPos);
+ }
+}
+//_____________________________________________
+void AliFemtoModelHiddenInfo::SetEmissionPoint(const AliFemtoLorentzVector& aPos)
+{
+ if (fEmissionPoint) {
+ fEmissionPoint->setX(aPos.px());
+ fEmissionPoint->setY(aPos.py());
+ fEmissionPoint->setZ(aPos.pz());
+ fEmissionPoint->setT(aPos.e());
+ }
+ else {
+ fEmissionPoint = new AliFemtoLorentzVector();
+ *fEmissionPoint = aPos;
+ }
+}
+//_____________________________________________
+void AliFemtoModelHiddenInfo::SetPDGPid(Int_t aPid)
+{
+ fPDGPid = aPid;
+}
+//_____________________________________________
+void AliFemtoModelHiddenInfo::SetMass(Double_t aMass)
+{
+ fMass = aMass;
+}
+//_____________________________________________
+void AliFemtoModelHiddenInfo::SetEmissionPoint(Double_t aRx, Double_t aRy, Double_t aRz, Double_t aT)
+{
+ fEmissionPoint->setX(aRx);
+ fEmissionPoint->setY(aRy);
+ fEmissionPoint->setZ(aRz);
+ fEmissionPoint->setT(aT);
+}
+//_____________________________________________
+ AliFemtoHiddenInfo* AliFemtoModelHiddenInfo::getParticleHiddenInfo() const
+{
+ AliFemtoModelHiddenInfo* tBuf = new AliFemtoModelHiddenInfo(*this);
+ return tBuf;
+}
--- /dev/null
+////////////////////////////////////////////////////////////////////////////////
+/// ///
+/// AliFemtoModelHiddenInfo - the hidden info for model calculations ///
+/// Stores information needed for the weight generation - the true ///
+/// simulated momenta, freeze-out coordinates from model and particle PID ///
+/// ///
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef AliFemtoModelHiddenInfo_hh
+#define AliFemtoModelHiddenInfo_hh
+
+#include <TH1D.h>
+#include "Infrastructure/AliFemtoTypes.h"
+#include "Infrastructure/AliFemtoThreeVector.h"
+#include "Infrastructure/AliFemtoLorentzVector.h"
+#include "Base/AliFemtoHiddenInfo.h"
+
+class AliFemtoModelHiddenInfo : public AliFemtoHiddenInfo{
+
+public:
+ AliFemtoModelHiddenInfo();
+ AliFemtoModelHiddenInfo(const AliFemtoModelHiddenInfo &aInfo);
+ virtual ~AliFemtoModelHiddenInfo();
+
+ AliFemtoModelHiddenInfo& operator=(const AliFemtoModelHiddenInfo& aInfo);
+ AliFemtoThreeVector *GetTrueMomentum() const;
+ AliFemtoLorentzVector *GetEmissionPoint() const;
+ Int_t GetPDGPid() const;
+ Double_t GetMass() const;
+
+ void SetTrueMomentum(AliFemtoThreeVector *aMom);
+ void SetTrueMomentum(const AliFemtoThreeVector& aMom);
+ void SetTrueMomentum(Double_t aPx, Double_t aPy, Double_t aPz);
+ void SetEmissionPoint(AliFemtoLorentzVector *aPos);
+ void SetEmissionPoint(const AliFemtoLorentzVector& aPos);
+ void SetEmissionPoint(Double_t aRx, Double_t aRy, Double_t aRz, Double_t aT);
+ void SetPDGPid(Int_t aPid);
+ void SetMass(Double_t aMass);
+
+// !!! MANDATORY !!!
+// --- Copy the hidden info from AliFemtoTrack to AliFemtoParticle
+ virtual AliFemtoHiddenInfo* getParticleHiddenInfo() const;
+ virtual AliFemtoHiddenInfo* clone() const;
+
+ protected:
+ AliFemtoThreeVector *fTrueMomentum; // True (simulated) momentum
+ AliFemtoLorentzVector *fEmissionPoint; // Emission point coordinates
+ Int_t fPDGPid; // True PID of the particle
+ Double_t fMass;
+};
+//_______________________________________
+inline AliFemtoHiddenInfo* AliFemtoModelHiddenInfo::clone() const{
+ // return exact copy of this hidden info
+ return getParticleHiddenInfo();
+}
+
+#endif
--- /dev/null
+////////////////////////////////////////////////////////////////////////////////
+/// ///
+/// AliFemtoModelManager - main helper class for femtoscopy calculations ///
+/// Manages weight generation, freeze-out coordinates generation ///
+/// Authors: Adam Kisiel kisiel@mps.ohio-state.edu ///
+/// ///
+////////////////////////////////////////////////////////////////////////////////
+#ifdef __ROOT__
+ ClassImp(AliFemtoModelManager, 1)
+#endif
+
+#include "AliFemtoModelManager.h"
+#include "AliFemtoModelHiddenInfo.h"
+
+//_____________________________________________
+AliFemtoModelManager::AliFemtoModelManager():
+ fFreezeOutGenerator(0),
+ fWeightGenerator(0),
+ fCreateCopyHiddenInfo(kFALSE)
+{
+}
+//_____________________________________________
+AliFemtoModelManager::AliFemtoModelManager(const AliFemtoModelManager& aManager):
+ fFreezeOutGenerator(0),
+ fWeightGenerator(0),
+ fCreateCopyHiddenInfo(aManager.fCreateCopyHiddenInfo)
+{
+ if (aManager.fFreezeOutGenerator) {
+ fFreezeOutGenerator = aManager.fFreezeOutGenerator->Clone();
+ }
+ if (aManager.fWeightGenerator) {
+ fWeightGenerator = aManager.fWeightGenerator->Clone();
+ }
+}
+//_____________________________________________
+AliFemtoModelManager::~AliFemtoModelManager()
+{
+ if (fFreezeOutGenerator) delete fFreezeOutGenerator;
+ if (fWeightGenerator) delete fWeightGenerator;
+}
+//_____________________________________________
+AliFemtoModelManager& AliFemtoModelManager::operator=(const AliFemtoModelManager& aManager)
+{
+ if (this == &aManager)
+ return *this;
+ if (aManager.fFreezeOutGenerator) {
+ fFreezeOutGenerator = aManager.fFreezeOutGenerator->Clone();
+ }
+ else fFreezeOutGenerator = 0;
+ if (aManager.fWeightGenerator) {
+ fWeightGenerator = aManager.fWeightGenerator->Clone();
+ }
+ else fWeightGenerator = 0;
+ fCreateCopyHiddenInfo = aManager.fCreateCopyHiddenInfo;
+
+ return *this;
+}
+//_____________________________________________
+void AliFemtoModelManager::AcceptFreezeOutGenerator(AliFemtoModelFreezeOutGenerator *aFreeze)
+{
+ fFreezeOutGenerator = aFreeze;
+}
+//_____________________________________________
+void AliFemtoModelManager::AcceptWeightGenerator(AliFemtoModelWeightGenerator *aWeight)
+{
+ fWeightGenerator = aWeight;
+}
+//_____________________________________________
+Double_t AliFemtoModelManager::GetWeight(AliFemtoPair *aPair)
+{
+ // Return femtoscopic weight for a fiven pair
+ if (fCreateCopyHiddenInfo) {
+ if (!(aPair->track1()->HiddenInfo())) {
+ AliFemtoModelHiddenInfo *inf1 = new AliFemtoModelHiddenInfo();
+ inf1->SetTrueMomentum(aPair->track1()->Track()->P());
+ inf1->SetMass(0.13957);
+ aPair->track1()->SetHiddenInfo(inf1);
+ delete inf1;
+ }
+ if (!(aPair->track2()->HiddenInfo())) {
+ AliFemtoModelHiddenInfo *inf2 = new AliFemtoModelHiddenInfo();
+ inf2->SetTrueMomentum(aPair->track2()->Track()->P());
+ inf2->SetMass(0.13957);
+ aPair->track2()->SetHiddenInfo(inf2);
+ delete inf2;
+ }
+ }
+
+ if (fFreezeOutGenerator) {
+ fFreezeOutGenerator->GenerateFreezeOut(aPair);
+ }
+ return fWeightGenerator->GenerateWeight(aPair);
+}
+//_____________________________________________
+void AliFemtoModelManager::CreateCopyHiddenInfo()
+{
+ fCreateCopyHiddenInfo = kTRUE;
+}
+//_____________________________________________
+AliFemtoModelFreezeOutGenerator* AliFemtoModelManager::GetFreezeOutGenerator()
+{
+ return fFreezeOutGenerator;
+}
+//_____________________________________________
+AliFemtoModelWeightGenerator* AliFemtoModelManager::GetWeightGenerator()
+{
+ return fWeightGenerator;
+}
--- /dev/null
+////////////////////////////////////////////////////////////////////////////////
+/// ///
+/// AliFemtoModelManager - main helper class for femtoscopy calculations ///
+/// Manages weight generation, freeze-out coordinates generation ///
+/// Authors: Adam Kisiel kisiel@mps.ohio-state.edu ///
+/// ///
+////////////////////////////////////////////////////////////////////////////////
+#ifndef AliFemtoModelManager_hh
+#define AliFemtoModelManager_hh
+
+#include "Infrastructure/AliFemtoEnumeration.h"
+#include "AliFemtoModelWeightGenerator.h"
+#include "AliFemtoModelFreezeOutGenerator.h"
+
+class AliFemtoModelManager
+{
+ public:
+ AliFemtoModelManager();
+ AliFemtoModelManager(const AliFemtoModelManager& aManager);
+ virtual ~AliFemtoModelManager();
+
+ AliFemtoModelManager& operator=(const AliFemtoModelManager& aManager);
+
+ void AcceptFreezeOutGenerator(AliFemtoModelFreezeOutGenerator *aFreeze);
+ void AcceptWeightGenerator(AliFemtoModelWeightGenerator *aWeight);
+ void CreateCopyHiddenInfo();
+
+ AliFemtoModelFreezeOutGenerator* GetFreezeOutGenerator();
+ AliFemtoModelWeightGenerator* GetWeightGenerator();
+
+ virtual Double_t GetWeight(AliFemtoPair *aPair);
+
+ protected:
+ AliFemtoModelFreezeOutGenerator *fFreezeOutGenerator; // Freeze-out coordinates generator
+ AliFemtoModelWeightGenerator *fWeightGenerator; // Femtoscopic weight generator
+ Bool_t fCreateCopyHiddenInfo; // Switch to turn on hidden-info generation
+
+ private:
+
+#ifdef __ROOT__
+ ClassDef(AliFemtoModelManager, 1)
+#endif
+
+ };
+
+#endif
+
+
--- /dev/null
+////////////////////////////////////////////////////////////////////////////////
+/// ///
+/// AliFemtoModelWeightGenerator - abstract base class for femtoscopic ///
+/// weight generator ///
+/// Authors: Adam Kisiel kisiel@mps.ohio-state.edu ///
+/// ///
+////////////////////////////////////////////////////////////////////////////////
+#ifdef __ROOT__
+ ClassImp(AliFemtoModelGausLCMSFreezeOutGenerator, 1)
+#endif
+
+#include "AliFemtoModelWeightGenerator.h"
+#include "AliFemtoModelHiddenInfo.h"
+
+const Int_t AliFemtoModelWeightGenerator::kPionPlusPionPlus = 1;
+const Int_t AliFemtoModelWeightGenerator::kPionPlusPionMinus = 2;
+const Int_t AliFemtoModelWeightGenerator::kKaonPlusKaonPlus = 3;
+const Int_t AliFemtoModelWeightGenerator::kKaonPlusKaonMinus = 4;
+const Int_t AliFemtoModelWeightGenerator::kProtonProton = 5;
+const Int_t AliFemtoModelWeightGenerator::kProtonAntiproton = 6;
+const Int_t AliFemtoModelWeightGenerator::kPionPlusKaonPlus = 7;
+const Int_t AliFemtoModelWeightGenerator::kPionPlusKaonMinus = 8;
+const Int_t AliFemtoModelWeightGenerator::kPionPlusProton = 9;
+const Int_t AliFemtoModelWeightGenerator::kPionPlusAntiproton = 10;
+const Int_t AliFemtoModelWeightGenerator::kKaonPlusProton = 11;
+const Int_t AliFemtoModelWeightGenerator::kKaonPlusAntiproton = 12;
+
+//_____________________________________________
+AliFemtoModelWeightGenerator::AliFemtoModelWeightGenerator() :
+ fPairType(0),
+ fKStarOut(0), fKStarSide(0), fKStarLong(0), fKStar(0),
+ fRStarOut(0), fRStarSide(0), fRStarLong(0), fRStar(0)
+{}
+//_____________________________________________
+AliFemtoModelWeightGenerator::AliFemtoModelWeightGenerator(const AliFemtoModelWeightGenerator &aModel) :
+ fPairType(0),
+ fKStarOut(0), fKStarSide(0), fKStarLong(0), fKStar(0),
+ fRStarOut(0), fRStarSide(0), fRStarLong(0), fRStar(0)
+{
+ fPairType = aModel.fPairType;
+}
+//_____________________________________________
+AliFemtoModelWeightGenerator::~AliFemtoModelWeightGenerator(){/* no-op */}
+//_____________________________________________
+void AliFemtoModelWeightGenerator::SetPairType(Int_t aPairType)
+{
+ fPairType = aPairType;
+}
+
+//_____________________________________________
+Int_t AliFemtoModelWeightGenerator::GetPairType()
+{
+ return fPairType;
+}
+
+//_____________________________________________
+void AliFemtoModelWeightGenerator::SetPairTypeFromPair(AliFemtoPair *aPair)
+{
+ AliFemtoModelHiddenInfo *inf1 = ( AliFemtoModelHiddenInfo *) aPair->track1()->HiddenInfo();
+ AliFemtoModelHiddenInfo *inf2 = ( AliFemtoModelHiddenInfo *) aPair->track2()->HiddenInfo();
+
+ const Int_t tPid1 = inf1->GetPDGPid();
+ const Int_t tPid2 = inf2->GetPDGPid();
+
+ if (((tPid1 == 211) && (tPid2 == 211)) ||
+ ((tPid1 == -211) && (tPid2 == -211)))
+ fPairType = kPionPlusPionPlus;
+ else if (((tPid1 == -211) && (tPid2 == 211)) ||
+ ((tPid1 == 211) && (tPid2 == -211)))
+ fPairType = kPionPlusPionMinus;
+ else if (((tPid1 == 321) && (tPid2 == 321)) ||
+ ((tPid1 == -321) && (tPid2 == -321)))
+ fPairType = kKaonPlusKaonPlus;
+ else if (((tPid1 == -321) && (tPid2 == 321)) ||
+ ((tPid1 == 321) && (tPid2 == -321)))
+ fPairType = kKaonPlusKaonMinus;
+ else if (((tPid1 == 2212) && (tPid2 == 2212)) ||
+ ((tPid1 == -2212) && (tPid2 == -2212)))
+ fPairType = kProtonProton;
+ else if (((tPid1 == -2212) && (tPid2 == 2212)) ||
+ ((tPid1 == 2212) && (tPid2 == -2212)))
+ fPairType = kProtonAntiproton;
+ else if (((tPid1 == 211) && (tPid2 == 321)) ||
+ ((tPid1 == -211) && (tPid2 == -321)))
+ fPairType = kPionPlusKaonPlus;
+ else if (((tPid1 == -211) && (tPid2 == 321)) ||
+ ((tPid1 == 211) && (tPid2 == -321)))
+ fPairType = kPionPlusKaonMinus;
+ else if (((tPid1 == 211) && (tPid2 == 2212)) ||
+ ((tPid1 == -211) && (tPid2 == -2212)))
+ fPairType = kPionPlusProton;
+ else if (((tPid1 == -211) && (tPid2 == 2212)) ||
+ ((tPid1 == 211) && (tPid2 == -2212)))
+ fPairType = kPionPlusAntiproton;
+ else if (((tPid1 == 321) && (tPid2 == 2212)) ||
+ ((tPid1 == -321) && (tPid2 == -2212)))
+ fPairType = kKaonPlusProton;
+ else if (((tPid1 == -321) && (tPid2 == 2212)) ||
+ ((tPid1 == 321) && (tPid2 == -2212)))
+ fPairType = kKaonPlusAntiproton;
+}
+
+//_____________________________________________
+AliFemtoModelWeightGenerator* AliFemtoModelWeightGenerator::Clone() const
+{
+ return 0;
+}
--- /dev/null
+////////////////////////////////////////////////////////////////////////////////
+/// ///
+/// AliFemtoModelWeightGenerator - abstract base class for femtoscopic ///
+/// weight generator ///
+/// Authors: Adam Kisiel kisiel@mps.ohio-state.edu ///
+/// ///
+////////////////////////////////////////////////////////////////////////////////
+#ifndef AliFemtoModelWeightGenerator_hh
+#define AliFemtoModelWeightGenerator_hh
+
+#include "TRandom2.h"
+#include "AliFemtoPair.h"
+
+class AliFemtoModelWeightGenerator
+{
+ public:
+ AliFemtoModelWeightGenerator();
+ AliFemtoModelWeightGenerator(const AliFemtoModelWeightGenerator &aModel);
+ virtual ~AliFemtoModelWeightGenerator();
+ virtual Double_t GenerateWeight(AliFemtoPair *aPair) = 0;
+
+ virtual void SetPairType(Int_t aPairType);
+ virtual void SetPairTypeFromPair(AliFemtoPair *aPair);
+ virtual Int_t GetPairType();
+
+ virtual Double_t GetKStar();
+ virtual Double_t GetKStarOut();
+ virtual Double_t GetKStarSide();
+ virtual Double_t GetKStarLong();
+ virtual Double_t GetRStar();
+ virtual Double_t GetRStarOut();
+ virtual Double_t GetRStarSide();
+ virtual Double_t GetRStarLong();
+
+ virtual AliFemtoModelWeightGenerator* Clone() const;
+
+ static const Int_t kPionPlusPionPlus;
+ static const Int_t kPionPlusPionMinus;
+ static const Int_t kKaonPlusKaonPlus;
+ static const Int_t kKaonPlusKaonMinus;
+ static const Int_t kProtonProton;
+ static const Int_t kProtonAntiproton;
+ static const Int_t kPionPlusKaonPlus;
+ static const Int_t kPionPlusKaonMinus;
+ static const Int_t kPionPlusProton;
+ static const Int_t kPionPlusAntiproton;
+ static const Int_t kKaonPlusProton;
+ static const Int_t kKaonPlusAntiproton;
+
+ protected:
+ Int_t fPairType;
+
+ Double_t fKStarOut; // relative momentum out component in PRF
+ Double_t fKStarSide; // relative momentum side component in PRF
+ Double_t fKStarLong; // relative momentum long component in PRF
+ Double_t fKStar; // relative momentum magnitude
+
+ Double_t fRStarOut; // relative separation out component in PRF
+ Double_t fRStarSide; // relative separation side component in PRF
+ Double_t fRStarLong; // relative separation long component in PRF
+ Double_t fRStar; // relative separation magnitude
+ private:
+
+#ifdef __ROOT__
+ ClassDef(AliFemtoModelWeightGenerator, 1)
+#endif
+
+ };
+
+inline Double_t AliFemtoModelWeightGenerator::GetKStar() { return fKStar; }
+inline Double_t AliFemtoModelWeightGenerator::GetKStarOut() { return fKStarOut; }
+inline Double_t AliFemtoModelWeightGenerator::GetKStarSide() { return fKStarSide; }
+inline Double_t AliFemtoModelWeightGenerator::GetKStarLong() { return fKStarLong; }
+inline Double_t AliFemtoModelWeightGenerator::GetRStar() { return fRStar; }
+inline Double_t AliFemtoModelWeightGenerator::GetRStarOut() { return fRStarOut; }
+inline Double_t AliFemtoModelWeightGenerator::GetRStarSide() { return fRStarSide; }
+inline Double_t AliFemtoModelWeightGenerator::GetRStarLong() { return fRStarLong; }
+
+
+#endif
+
+
--- /dev/null
+////////////////////////////////////////////////////////////////////////////////
+/// ///
+/// AliFemtoModelWeightGeneratorBasic - basic femtoscopic weight generator ///
+/// only return a simple ///
+/// Authors: Adam Kisiel kisiel@mps.ohio-state.edu ///
+/// ///
+////////////////////////////////////////////////////////////////////////////////
+#ifdef __ROOT__
+ ClassImp(AliFemtoModelWeightGeneratorBasic, 1)
+#endif
+
+#include "AliFemtoModelWeightGeneratorBasic.h"
+#include "AliFemtoModelHiddenInfo.h"
+
+//________________________
+AliFemtoModelWeightGeneratorBasic::AliFemtoModelWeightGeneratorBasic():
+ AliFemtoModelWeightGenerator()
+{
+ /* no-op */
+}
+//________________________
+AliFemtoModelWeightGeneratorBasic::AliFemtoModelWeightGeneratorBasic(const AliFemtoModelWeightGeneratorBasic &aModel) :
+ AliFemtoModelWeightGenerator(aModel)
+{
+ /* no-op */
+}
+
+//________________________
+AliFemtoModelWeightGeneratorBasic::~AliFemtoModelWeightGeneratorBasic()
+{
+ /* no-op */
+}
+
+//________________________
+Double_t AliFemtoModelWeightGeneratorBasic::GenerateWeight(AliFemtoPair *aPair)
+{
+ // Generate a simple femtoscopic weight coming only from
+ // quantum statistics - symmetrization or anti-symmetrization
+ // of the pair wave function
+
+ // Get hidden information pointers
+ AliFemtoModelHiddenInfo *inf1 = (AliFemtoModelHiddenInfo *) aPair->track1()->HiddenInfo();
+ AliFemtoModelHiddenInfo *inf2 = (AliFemtoModelHiddenInfo *) aPair->track2()->HiddenInfo();
+
+ // Calculate pair variables
+ Double_t tPx = inf1->GetTrueMomentum()->x()+inf2->GetTrueMomentum()->x();
+ Double_t tPy = inf1->GetTrueMomentum()->y()+inf2->GetTrueMomentum()->y();
+ Double_t tPz = inf1->GetTrueMomentum()->z()+inf2->GetTrueMomentum()->z();
+ // double tE = inf1->GetTrueMomentum()->e +inf2->GetTrueMomentum()->.e;
+ Double_t tM1 = inf1->GetMass();
+ Double_t tM2 = inf2->GetMass();
+ Double_t tE1 = sqrt(tM1*tM1 + inf1->GetTrueMomentum()->mag2());
+ Double_t tE2 = sqrt(tM2*tM2 + inf2->GetTrueMomentum()->mag2());
+ Double_t tE = tE1 + tE2;
+ Double_t tPt = tPx*tPx + tPy*tPy;
+ Double_t tMt = tE*tE - tPz*tPz;//mCVK;
+ Double_t tM = sqrt(tMt - tPt);
+ tMt = sqrt(tMt);
+ tPt = sqrt(tPt);
+ Double_t tBetat = tPt/tMt;
+
+ // Boost to LCMS
+ Double_t tBeta = tPz/tE;
+ Double_t tGamma = tE/tMt;
+ fKStarLong = tGamma * (inf1->GetTrueMomentum()->z() - tBeta * tE1);
+ Double_t tE1L = tGamma * (tE1 - tBeta * inf1->GetTrueMomentum()->z());
+
+ // Transform positions to LCMS
+// Double_t tP1zl = tGamma * (inf1->GetEmissionPoint()->z() - tBeta * inf1->GetEmissionPoint()->t());
+// Double_t tP1tl = tGamma * (inf1->GetEmissionPoint()->t() - tBeta * inf1->GetEmissionPoint()->z());
+
+// Double_t tP2zl = tGamma * (inf2->GetEmissionPoint()->z() - tBeta * inf2->GetEmissionPoint()->t());
+// Double_t tP2tl = tGamma * (inf2->GetEmissionPoint()->t() - tBeta * inf2->GetEmissionPoint()->z());
+
+// Double_t tP1pzl = tGamma * (inf1->GetTrueMomentum()->z() - tBeta * tE1);
+// Double_t tP1el = tGamma * (tE1 - tBeta * inf1->GetTrueMomentum()->z());
+
+// Double_t tP2pzl = tGamma * (inf2->GetTrueMomentum()->z() - tBeta * tE2);
+// Double_t tP2el = tGamma * (tE2 - tBeta * inf2->GetTrueMomentum()->z());
+
+ // Rotate in transverse plane
+ fKStarOut = ( inf1->GetTrueMomentum()->x()*tPx + inf1->GetTrueMomentum()->y()*tPy)/tPt;
+ fKStarSide = (-inf1->GetTrueMomentum()->x()*tPy + inf1->GetTrueMomentum()->y()*tPx)/tPt;
+
+// Double_t tP1pxl = fKStarOut;
+// Double_t tP1pyl = fKStarSide;
+
+// Double_t tP2pxl = (inf2->GetTrueMomentum()->x()*tPx + inf2->GetTrueMomentum()->y()*tPy)/tPt;
+// Double_t tP2pyl = (inf2->GetTrueMomentum()->y()*tPx - inf2->GetTrueMomentum()->x()*tPy)/tPt;;
+
+// Double_t tKO = tP1pxl - tP2pxl;
+// Double_t tKS = tP1pyl - tP2pyl;
+// Double_t tKL = tP1pzl - tP2pzl;
+// Double_t tDE = tP1el - tP2el;
+
+ // save the rotated coordinates in LCMS variables
+// Double_t tP1xl = ( inf1->GetEmissionPoint()->x()*tPx + inf1->GetEmissionPoint()->y()*tPy)/tPt;
+// Double_t tP1yl = (-inf1->GetEmissionPoint()->x()*tPy + inf1->GetEmissionPoint()->y()*tPx)/tPt;
+
+// Double_t tP2xl = ( inf2->GetEmissionPoint()->x()*tPx + inf2->GetEmissionPoint()->y()*tPy)/tPt;
+// Double_t tP2yl = (-inf2->GetEmissionPoint()->x()*tPy + inf2->GetEmissionPoint()->y()*tPx)/tPt;
+
+ // Boost to pair cms
+ fKStarOut = tMt/tM * (fKStarOut - tPt/tMt * tE1L);
+
+ tBetat = tPt/tMt;
+// Double_t tGammat = 1.0/sqrt(1.0-tBetat*tBetat);
+
+// Double_t tP1xp = tGammat*(tP1xl - tBetat*tP1tl);
+// Double_t tP1tp = tGammat*(tP1tl - tBetat*tP1xl);
+
+// Double_t tP2xp = tGammat*(tP2xl - tBetat*tP2tl);
+// Double_t tP2tp = tGammat*(tP2tl - tBetat*tP2xl);
+
+// Double_t tRO = (tP1xl - tP2xl)/0.197327;
+// Double_t tRS = (tP1yl - tP2yl)/0.197327;
+// Double_t tRL = (tP1zl - tP2zl)/0.197327;
+// Double_t tDT = (tP1tl - tP2tl)/0.197327;
+
+ Double_t tDX = inf1->GetEmissionPoint()->x()-inf2->GetEmissionPoint()->x();
+ Double_t tDY = inf1->GetEmissionPoint()->y()-inf2->GetEmissionPoint()->y();
+ Double_t tRLong = inf1->GetEmissionPoint()->z()-inf2->GetEmissionPoint()->z();
+ Double_t tDTime = inf1->GetEmissionPoint()->t()-inf2->GetEmissionPoint()->t();
+
+ Double_t tROut = (tDX*tPx + tDY*tPy)/tPt;
+ Double_t tRSide = (-tDX*tPy + tDY*tPx)/tPt;
+
+ fRStarSide = tRSide;
+ Double_t tRSS = fRStarSide/0.197327;
+
+ fRStarLong = tGamma*(tRLong - tBeta* tDTime);
+ Double_t tDTimePairLCMS = tGamma*(tDTime - tBeta* tRLong);
+
+ Double_t tRLS = fRStarLong/0.197327;
+ tBeta = tPt/tMt;
+ tGamma = tMt/tM;
+
+ fRStarOut = tGamma*(tROut - tBeta* tDTimePairLCMS);
+ Double_t tROS = fRStarOut/0.197327;
+// Double_t tDTimePairCMS = tGamma*(tDTimePairLCMS - tBeta* tROut);
+ fRStar = ::sqrt(fRStarOut*fRStarOut + fRStarSide*fRStarSide +
+ fRStarLong*fRStarLong);
+ fKStar = ::sqrt(fKStarOut*fKStarOut + fKStarSide*fKStarSide + fKStarLong*fKStarLong);
+// Double_t tRSt = fRStar/0.197327;
+
+ if ((fPairType == kPionPlusPionPlus) || (fPairType == kKaonPlusKaonPlus))
+ return 1.0 + cos (2*(fKStarOut * tROS + fKStarSide * tRSS + fKStarLong * tRLS));
+ else if (fPairType == kProtonProton)
+ return 1.0 - 0.5 * cos (2*(fKStarOut * tROS + fKStarSide * tRSS + fKStarLong * tRLS));
+ else
+ return 1.0;
+}
+
+//________________________
+void AliFemtoModelWeightGeneratorBasic::SetPairType(Int_t aPairType)
+{
+ AliFemtoModelWeightGenerator::SetPairType(aPairType);
+}
+//________________________
+void AliFemtoModelWeightGeneratorBasic::SetPairTypeFromPair(AliFemtoPair *aPair)
+{
+ AliFemtoModelWeightGenerator::SetPairTypeFromPair(aPair);
+}
+//________________________
+Int_t AliFemtoModelWeightGeneratorBasic::GetPairType()
+{
+ return AliFemtoModelWeightGenerator::GetPairType();
+}
+//________________________
+AliFemtoModelWeightGenerator* AliFemtoModelWeightGeneratorBasic::Clone() const
+{
+ return GetGenerator();
+}
+//________________________
+AliFemtoModelWeightGenerator* AliFemtoModelWeightGeneratorBasic::GetGenerator() const
+{
+ AliFemtoModelWeightGeneratorBasic *tGen = new AliFemtoModelWeightGeneratorBasic(*this);
+ return tGen;
+}
--- /dev/null
+////////////////////////////////////////////////////////////////////////////////
+/// ///
+/// AliFemtoModelWeightGeneratorBasic - basic femtoscopic weight generator ///
+/// only return a simple ///
+/// Authors: Adam Kisiel kisiel@mps.ohio-state.edu ///
+/// ///
+////////////////////////////////////////////////////////////////////////////////
+#ifndef AliFemtoModelWeightGeneratorBasic_hh
+#define AliFemtoModelWeightGeneratorBasic_hh
+
+#include "TRandom2.h"
+#include "AliFemtoPair.h"
+#include "AliFemtoModelWeightGenerator.h"
+
+class AliFemtoModelWeightGeneratorBasic : public AliFemtoModelWeightGenerator
+{
+ public:
+ AliFemtoModelWeightGeneratorBasic();
+ AliFemtoModelWeightGeneratorBasic(const AliFemtoModelWeightGeneratorBasic &aModel);
+ virtual ~AliFemtoModelWeightGeneratorBasic();
+ virtual Double_t GenerateWeight(AliFemtoPair *aPair);
+
+ virtual void SetPairType(Int_t aPairType);
+ virtual void SetPairTypeFromPair(AliFemtoPair *aPair);
+ virtual Int_t GetPairType();
+
+ virtual AliFemtoModelWeightGenerator* Clone() const;
+ protected:
+
+ private:
+ AliFemtoModelWeightGenerator* GetGenerator() const;
+
+#ifdef __ROOT__
+ ClassDef(AliFemtoModelWeightGeneratorBasic, 1)
+#endif
+
+ };
+
+#endif
+
+
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff