|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
#include "GeneratorInterface/Core/interface/BaseHadronizer.h"
#include "FWCore/ParameterSet/interface/Registry.h"
#include <random>
#include <sys/wait.h>
namespace gen {
const std::vector<std::string> BaseHadronizer::theSharedResources;
BaseHadronizer::BaseHadronizer(edm::ParameterSet const& ps) : randomIndex_(-1), gridpackPaths_(1) {
if (ps.exists("RandomizedParameters")) {
std::vector<edm::ParameterSet> randomizedParameters =
ps.getParameter<std::vector<edm::ParameterSet> >("RandomizedParameters");
randomInitWeights_.resize(randomizedParameters.size());
randomInitConfigDescriptions_.resize(randomizedParameters.size());
gridpackPaths_.resize(randomizedParameters.size());
for (unsigned int irand = 0; irand < randomizedParameters.size(); ++irand) {
randomInitWeights_[irand] = randomizedParameters[irand].getParameter<double>("ConfigWeight");
if (randomizedParameters[irand].exists("ConfigDescription")) {
randomInitConfigDescriptions_[irand] =
randomizedParameters[irand].getParameter<std::string>("ConfigDescription");
}
if (randomizedParameters[irand].exists("GridpackPath")) {
gridpackPaths_[irand] = randomizedParameters[irand].getParameter<std::string>("GridpackPath");
}
}
} else {
if (ps.exists("GridpackPath")) {
gridpackPaths_[0] = ps.getParameter<std::string>("GridpackPath");
}
}
runInfo().setFilterEfficiency(ps.getUntrackedParameter<double>("filterEfficiency", -1.));
runInfo().setExternalXSecLO(GenRunInfoProduct::XSec(ps.getUntrackedParameter<double>("crossSection", -1.)));
runInfo().setExternalXSecNLO(GenRunInfoProduct::XSec(ps.getUntrackedParameter<double>("crossSectionNLO", -1.)));
}
std::unique_ptr<GenLumiInfoHeader> BaseHadronizer::getGenLumiInfoHeader() const {
auto genLumiInfoHeader = std::make_unique<GenLumiInfoHeader>();
//fill information on randomized configs for parameter scans
genLumiInfoHeader->setRandomConfigIndex(randomIndex_);
if (randomIndex_ >= 0) {
genLumiInfoHeader->setConfigDescription(randomInitConfigDescription());
}
return genLumiInfoHeader;
}
void BaseHadronizer::randomizeIndex(edm::LuminosityBlock const& lumi, CLHEP::HepRandomEngine* rengine) {
if (!randomInitWeights_.empty()) {
//randomly select from a list of provided configuration sets (for parameter scans)
//seeds std 32-bit mersene twister with HepRandomEngine state plus run and lumi section numbers
//(random engine state will be the same for every lumi section in a job)
std::vector<long unsigned int> seeds = rengine->put();
seeds.push_back(lumi.id().run());
seeds.push_back(lumi.id().luminosityBlock());
std::seed_seq seedseq(seeds.begin(), seeds.end());
std::mt19937 randgen(seedseq);
std::discrete_distribution<int> randdist(randomInitWeights_.begin(), randomInitWeights_.end());
randomIndex_ = randdist(randgen);
}
}
void BaseHadronizer::generateLHE(edm::LuminosityBlock const& lumi,
CLHEP::HepRandomEngine* rengine,
unsigned int ncpu) {
if (gridpackPath().empty()) {
return;
}
//get random seed from HepRandomEngine state plus run and lumi section numbers
//(random engine state will be the same for every lumi section in a job)
std::vector<long unsigned int> seeds = rengine->put();
seeds.push_back(lumi.id().run());
seeds.push_back(lumi.id().luminosityBlock());
std::seed_seq seedseq(seeds.begin(), seeds.end());
std::array<unsigned int, 1> lheseed;
seedseq.generate(lheseed.begin(), lheseed.end());
constexpr unsigned int maxseed = 30081 * 30081; //madgraph cannot handle seeds larger than this
unsigned int seedval = lheseed[0] % (maxseed + 1);
unsigned int nevents = edm::pset::Registry::instance()
->getMapped(lumi.processHistory().rbegin()->parameterSetID())
->getParameter<edm::ParameterSet>("@main_input")
.getUntrackedParameter<unsigned int>("numberEventsInLuminosityBlock");
std::ostringstream nevStream;
nevStream << nevents;
std::ostringstream randomStream;
randomStream << seedval;
edm::FileInPath script("GeneratorInterface/LHEInterface/data/run_generic_tarball_cvmfs.sh");
const char* outfilename = "cmsgrid_final.lhe";
std::array<std::string, 5> argStrs;
argStrs[0] = script.fullPath();
argStrs[1] = gridpackPath();
argStrs[2] = nevStream.str();
argStrs[3] = randomStream.str();
argStrs[4] = std::to_string(ncpu);
std::array<char*, 6> args{
{&argStrs[0][0], &argStrs[1][0], &argStrs[2][0], &argStrs[3][0], &argStrs[4][0], nullptr}};
pid_t pid = fork();
if (pid == -1) {
// error, failed to fork()
throw cms::Exception("BaseHadronizer::generateLHE") << "Unable to fork a child";
} else if (pid == 0) {
//child
execvp(args[0], std::begin(args));
_exit(1); // exec never returns
} else {
//parent
int status;
waitpid(pid, &status, 0);
if (status) {
throw cms::Exception("BaseHadronizer::generateLHE") << "Failed to execute script";
}
}
FILE* lhef = std::fopen(outfilename, "r");
if (!lhef) {
throw cms::Exception("BaseHadronizer::generateLHE") << "Output file " << outfilename << " not found.";
}
std::fclose(lhef);
lheFile_ = outfilename;
}
void BaseHadronizer::cleanLHE() {
if (lheFile_.empty()) {
return;
}
std::remove(lheFile_.c_str());
}
} // namespace gen
|