diff --git a/MC/config/PWGDQ/external/generator/generator_likeSignDimuon_gaptriggered.C b/MC/config/PWGDQ/external/generator/generator_likeSignDimuon_gaptriggered.C new file mode 100644 index 000000000..e0204d599 --- /dev/null +++ b/MC/config/PWGDQ/external/generator/generator_likeSignDimuon_gaptriggered.C @@ -0,0 +1,130 @@ +#include "FairGenerator.h" +#include "Generators/GeneratorPythia8.h" +#include "Pythia8/Pythia.h" +#include "TRandom.h" + +#include +#include + +using namespace o2::eventgen; + +namespace o2 +{ +namespace eventgen +{ + +class GeneratorLikeSignDimuonGapTriggered : public o2::eventgen::GeneratorPythia8 { +public: + + /// constructor + GeneratorLikeSignDimuonGapTriggered(int inputTriggerRatio = 3) + { + mGeneratedEvents = 0; + mInverseTriggerRatio = inputTriggerRatio; + mRequiredMuonMultiplicity = 2; + mMuonRapidityMin = -4.3; + mMuonRapidityMax = -2.2; + mVerbose = false; + + // minimum-bias Pythia8 instance + auto seed = (gRandom->TRandom::GetSeed() % 900000000); + TString pathconfigMB = gSystem->ExpandPathName("$O2DPG_MC_CONFIG_ROOT/MC/config/PWGDQ/pythia8/generator/pythia8_inel_cr2.cfg"); + pythiaMBgen.readFile(pathconfigMB.Data()); + pythiaMBgen.readString("Random:setSeed on"); + pythiaMBgen.readString("Random:seed " + std::to_string(seed)); + } + /// Destructor + ~GeneratorLikeSignDimuonGapTriggered() = default; + + void setMuonMultiplicity(int n) { mRequiredMuonMultiplicity = n; } + void setMuonRapidity(double yMin, double yMax) + { + mMuonRapidityMin = yMin; + mMuonRapidityMax = yMax; + } + void setVerbose(bool v) { mVerbose = v; } + + protected: + + Bool_t generateEvent() override + { + if (mGeneratedEvents % mInverseTriggerRatio == 0) { + // signal event: keep generating until like-sign dimuon found + bool genOk = false; + while (!genOk) { + mPythia.event.reset(); + genOk = GeneratorPythia8::generateEvent(); + if (genOk) genOk = selectLikeSignDimuon(mPythia.event); + } + } else { + // minimum-bias event from the independent generator + bool genOk = false; + pythiaMBgen.event.reset(); + while (!genOk) genOk = pythiaMBgen.next(); + mPythia.event = pythiaMBgen.event; + } + mGeneratedEvents++; + if (mVerbose) mOutputEvent.list(); + return true; + } + + Bool_t Init() override + { + GeneratorPythia8::Init(); + pythiaMBgen.init(); + return true; + } + + // Accept the event if at least mRequiredMuonMultiplicity muons fall in the rapidity window AND at least one same-sign pair exists among them. + bool selectLikeSignDimuon(Pythia8::Event& event) + { + std::vector muonsInWindow; + for (int ipa = 0; ipa < event.size(); ++ipa) { + if (std::abs(event[ipa].id()) != 13) continue; + float rap = event[ipa].y(); + if (rap > mMuonRapidityMin && rap < mMuonRapidityMax) { + muonsInWindow.push_back(&event[ipa]); + } + } + if ((int)muonsInWindow.size() < mRequiredMuonMultiplicity) return false; + for (size_t i = 0; i < muonsInWindow.size(); ++i) { + for (size_t j = i + 1; j < muonsInWindow.size(); ++j) { + if (muonsInWindow[i]->id() * muonsInWindow[j]->id() > 0) return true; + } + } + return false; + } + + private: + Pythia8::Event mOutputEvent; + + unsigned long long mGeneratedEvents; + int mInverseTriggerRatio; + Pythia8::Pythia pythiaMBgen; + + int mRequiredMuonMultiplicity; + double mMuonRapidityMin; + double mMuonRapidityMax; + bool mVerbose; +}; + +} // namespace eventgen +} // namespace o2 + +FairGenerator* GeneratorLikeSignDimuonGapTriggered_dq(double rapidityMin = -4.3, double rapidityMax = -2.2, int requiredMuons = 2, int inputTriggerRatio = 3, bool verbose = false) +{ + auto gen = new o2::eventgen::GeneratorLikeSignDimuonGapTriggered(inputTriggerRatio); + gen->setMuonMultiplicity(requiredMuons); + gen->setMuonRapidity(rapidityMin, rapidityMax); + gen->setVerbose(verbose); + + // random seed + gen->readString("Random:setSeed on"); + uint random_seed; + unsigned long long int random_value = 0; + std::ifstream urandom("/dev/urandom", std::ios::in | std::ios::binary); + urandom.read(reinterpret_cast(&random_value), sizeof(random_seed)); + gen->readString(Form("Random:seed = %d", random_value % 900000001)); + + return gen; +} diff --git a/MC/config/PWGDQ/ini/Generator_likeSignDimuon_TriggerGap.ini b/MC/config/PWGDQ/ini/Generator_likeSignDimuon_TriggerGap.ini new file mode 100644 index 000000000..1fe1d0825 --- /dev/null +++ b/MC/config/PWGDQ/ini/Generator_likeSignDimuon_TriggerGap.ini @@ -0,0 +1,8 @@ +### The external generator derives from GeneratorPythia8. +[GeneratorExternal] +fileName=${O2DPG_MC_CONFIG_ROOT}/MC/config/PWGDQ/external/generator/generator_likeSignDimuon_gaptriggered.C +funcName=GeneratorLikeSignDimuonGapTriggered_dq(-4.3, -2.2, 2, 3) + +[GeneratorPythia8] +config=${O2DPG_MC_CONFIG_ROOT}/MC/config/PWGDQ/pythia8/generator/pythia8_inel_cr2.cfg +includePartonEvent=true diff --git a/MC/config/PWGDQ/ini/tests/Generator_likeSignDimuon_TriggerGap.C b/MC/config/PWGDQ/ini/tests/Generator_likeSignDimuon_TriggerGap.C new file mode 100644 index 000000000..67d4104d0 --- /dev/null +++ b/MC/config/PWGDQ/ini/tests/Generator_likeSignDimuon_TriggerGap.C @@ -0,0 +1,72 @@ +int External() +{ + std::string path{"o2sim_Kine.root"}; + TFile file(path.c_str(), "READ"); + if (file.IsZombie()) { + std::cerr << "Cannot open ROOT file " << path << "\n"; + return 1; + } + + auto tree = (TTree*)file.Get("o2sim"); + std::vector* tracks{}; + tree->SetBranchAddress("MCTrack", &tracks); + + int nMuons{}; + int nMuonsInAcc{}; + int nMuonsToBeDone{}; + int nLikeSignPairs{}; + int nLikeSignPairsInAcc{}; + int nLikeSignPairsToBeDone{}; + int nEvents = tree->GetEntries(); + + for (int i = 0; i < nEvents; i++) { + tree->GetEntry(i); + int nPos = 0, nNeg = 0; + int nPosAcc = 0, nNegAcc = 0; + int nPosToBeDone = 0, nNegToBeDone = 0; + + for (auto& track : *tracks) { + int pdg = track.GetPdgCode(); + if (std::abs(pdg) != 13) continue; + double y = track.GetRapidity(); + bool inAcc = (y > -4.3 && y < -2.2); + bool toBeDone = track.getToBeDone(); + + if (pdg == -13) { // mu+ + nPos++; + if (inAcc) nPosAcc++; + if (toBeDone) nPosToBeDone++; + } else { // mu- + nNeg++; + if (inAcc) nNegAcc++; + if (toBeDone) nNegToBeDone++; + } + } + nMuons += nPos + nNeg; + nMuonsInAcc += nPosAcc + nNegAcc; + nMuonsToBeDone += nPosToBeDone + nNegToBeDone; + + nLikeSignPairs += nPos * (nPos - 1) / 2 + nNeg * (nNeg - 1) / 2; + nLikeSignPairsInAcc += nPosAcc * (nPosAcc - 1) / 2 + nNegAcc * (nNegAcc - 1) / 2; + nLikeSignPairsToBeDone += nPosToBeDone * (nPosToBeDone - 1) / 2 + nNegToBeDone * (nNegToBeDone - 1) / 2; + } + + std::cout << "#events: " << nEvents << "\n" + << "#muons: " << nMuons << "\n" + << "#muons in acceptance: " << nMuonsInAcc << "\n" + << "#muons to be done: " << nMuonsToBeDone << "\n" + << "#like-sign muon pairs: " << nLikeSignPairs << "\n" + << "#like-sign muon pairs in acceptance: " << nLikeSignPairsInAcc << "\n" + << "#like-sign muon pairs to be done: " << nLikeSignPairsToBeDone << "\n"; + + if (nLikeSignPairs == 0) { + std::cerr << "Number of like-sign muon pairs should be greater than 0.\n"; + return 1; + } + if (nLikeSignPairs != nLikeSignPairsToBeDone) { + std::cerr << "The number of muon pairs should be the same as the number of muon pairs which should be transported.\n"; + return 1; + } + + return 0; +}