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..37c6c9877 --- /dev/null +++ b/MC/config/PWGDQ/external/generator/generator_likeSignDimuon_gaptriggered.C @@ -0,0 +1,132 @@ +#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 Init() override + { + addSubGenerator(0, "Minimum bias"); + addSubGenerator(1, "Like-sign dimuon injected"); + GeneratorPythia8::Init(); + pythiaMBgen.init(); + return true; + } + 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); + } + notifySubGenerator(1); + } else { + // minimum-bias event from the independent generator + bool genOk = false; + pythiaMBgen.event.reset(); + while (!genOk) genOk = pythiaMBgen.next(); + mPythia.event = pythiaMBgen.event; + notifySubGenerator(0); + } + mGeneratedEvents++; + if (mVerbose) mOutputEvent.list(); + 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..60a236e23 --- /dev/null +++ b/MC/config/PWGDQ/ini/tests/Generator_likeSignDimuon_TriggerGap.C @@ -0,0 +1,89 @@ +int External() +{ + const int ratioTrigger = 1./3; + 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); + + o2::dataformats::MCEventHeader* eventHeader = nullptr; + tree->SetBranchAddress("MCEventHeader.", &eventHeader); + + int nEvents = tree->GetEntries(); + int nEventsMB = 0; + int nEventsSignal = 0; + int nEventsWithLSM = 0; + int nMuonsInAcceptance = 0; + int nLSMPairs = 0; + + for (int i = 0; i < nEvents; i++) { + tree->GetEntry(i); + if (eventHeader->hasInfo(o2::mcgenid::GeneratorProperty::SUBGENERATORID)) { + bool isValid = false; + int subGeneratorId = eventHeader->getInfo( + o2::mcgenid::GeneratorProperty::SUBGENERATORID, isValid); + if (subGeneratorId == 0) { + nEventsMB++; + } else if (subGeneratorId == 1) { + nEventsSignal++; + } + } + + std::vector muonPDGs; + for (const auto& track : *tracks) { + if (std::abs(track.GetPdgCode()) != 13) { + continue; + } + double y = track.GetRapidity(); + if (y > -4.3 && y < -2.2) { + muonPDGs.push_back(track.GetPdgCode()); + nMuonsInAcceptance++; + } + } + if (muonPDGs.size() < 2) { + continue; + } + int nLsmPairsEvent = 0; + for (size_t j = 0; j < muonPDGs.size(); j++) { + for (size_t k = j + 1; k < muonPDGs.size(); k++) { + if (muonPDGs[j] * muonPDGs[k] > 0) { + nLsmPairsEvent++; + } + } + } + if (nLsmPairsEvent > 0) { + nEventsWithLSM++; + nLSMPairs += nLsmPairsEvent; + } + } + + std::cout << "#events: " << nEvents << "\n" + << "#minimum bias events: " << nEventsMB << "\n" + << "#trigger events: " << nEventsSignal << "\n" + << "#events with like-sign muons: " << nEventsWithLSM << "\n" + << "#muons in acceptance: " << nMuonsInAcceptance << "\n" + << "#like-sign dimuon pairs in acceptance: " << nLSMPairs << "\n"; + + if (nLSMPairs == 0) { + std::cerr << "Number of like-sign muon pairs should be greater than 0.\n"; + return 1; + } + if (nEventsMB < nEvents * (1 - ratioTrigger) * 0.95 || + nEventsMB > nEvents * (1 - ratioTrigger) * 1.05) { // we put some tolerance since the number of generated events is small + std::cerr << "Number of generated MB events different than expected\n"; + return 1; + } + if (nEventsSignal < nEvents * ratioTrigger * 0.95 || + nEventsSignal > nEvents * ratioTrigger * 1.05) { + std::cerr << "Number of generated events injected different than expected\n"; + return 1; + } + + return 0; +}