CMS 3D CMS Logo

L1TGlobalPrescalesVetosFractESProducer.cc
Go to the documentation of this file.
1 
10 // system include files
11 #include <memory>
12 #include <iostream>
13 #include <fstream>
14 #include <unistd.h>
15 #include <cstdio>
16 #include <cstdlib>
17 
18 #include "tmEventSetup/tmEventSetup.hh"
19 #include "tmEventSetup/esTriggerMenu.hh"
20 #include "tmEventSetup/esAlgorithm.hh"
21 #include "tmEventSetup/esCondition.hh"
22 #include "tmEventSetup/esObject.hh"
23 #include "tmEventSetup/esCut.hh"
24 #include "tmEventSetup/esScale.hh"
25 #include "tmGrammar/Algorithm.hh"
26 
32 
34 
37 
41 
42 using namespace std;
43 using namespace edm;
44 using namespace l1t;
45 //
46 // class declaration
47 //
48 
50 public:
53 
54  using ReturnType = std::unique_ptr<L1TGlobalPrescalesVetosFract>;
55 
57 
58 private:
60 
61  unsigned int m_numberPhysTriggers;
64 
65  std::vector<std::vector<double> > m_initialPrescaleFactorsAlgoTrig;
66  std::vector<unsigned int> m_initialTriggerMaskAlgoTrig;
68  std::map<int, std::vector<int> > m_initialTriggerAlgoBxMaskAlgoTrig;
69 };
70 
71 //
72 // constants, enums and typedefs
73 //
74 
75 //
76 // static data member definitions
77 //
78 
79 //
80 // constructors and destructor
81 //
83  : data_(new L1TGlobalPrescalesVetosFract()) {
84  //the following line is needed to tell the framework what
85  // data is being produced
86  setWhatProduced(this);
87  //setWhatProduced(this, conf.getParameter<std::string>("label"));
88 
90 
91  // directory in /data/Luminosity for the trigger menu
92  std::string menuDir = conf.getParameter<std::string>("TriggerMenuLuminosity");
93  //std::string menuDir = "startup";
94 
95  m_verbosity = conf.getParameter<int>("Verbosity");
96  m_bx_mask_default = conf.getParameter<int>("AlgoBxMaskDefault");
97 
98  // XML files
99  std::string prescalesFileName = conf.getParameter<std::string>("PrescaleXMLFile");
100  std::string algobxmaskFileName = conf.getParameter<std::string>("AlgoBxMaskXMLFile");
101  std::string finormaskFileName = conf.getParameter<std::string>("FinOrMaskXMLFile");
102  std::string vetomaskFileName = conf.getParameter<std::string>("VetoMaskXMLFile");
103 
104  // Full path
105  edm::FileInPath f1_prescale("L1Trigger/L1TGlobal/data/Luminosity/" + menuDir + "/" + prescalesFileName);
106  std::string m_prescaleFile = f1_prescale.fullPath();
107 
108  edm::FileInPath f1_mask_algobx("L1Trigger/L1TGlobal/data/Luminosity/" + menuDir + "/" + algobxmaskFileName);
109  std::string m_algobxmaskFile = f1_mask_algobx.fullPath();
110 
111  edm::FileInPath f1_mask_finor("L1Trigger/L1TGlobal/data/Luminosity/" + menuDir + "/" + finormaskFileName);
112  std::string m_finormaskFile = f1_mask_finor.fullPath();
113 
114  edm::FileInPath f1_mask_veto("L1Trigger/L1TGlobal/data/Luminosity/" + menuDir + "/" + vetomaskFileName);
115  std::string m_vetomaskFile = f1_mask_veto.fullPath();
116 
117  // XML payloads
118  std::string xmlPayload_prescale;
119  std::string xmlPayload_mask_algobx;
120  std::string xmlPayload_mask_finor;
121  std::string xmlPayload_mask_veto;
122 
123  std::vector<std::vector<double> > prescales;
124  std::vector<unsigned int> triggerMasks;
125  std::vector<int> triggerVetoMasks;
126  std::map<int, std::vector<int> > triggerAlgoBxMaskAlgoTrig;
127 
128  // Prescales
129  std::ifstream input_prescale;
130  input_prescale.open(m_prescaleFile);
131  if (not m_prescaleFile.empty() and not input_prescale) {
132  edm::LogError("L1TGlobalPrescalesVetosFractESProducer")
133  << "\nCould not find prescale file: " << m_prescaleFile
134  << "\nDeafulting to a single prescale column, with all prescales set to 1 (unprescaled)";
135 
136  const int inputDefaultPrescale = 1;
137  // by default, fill a single prescale column
138  prescales.push_back(std::vector<double>(m_numberPhysTriggers, inputDefaultPrescale));
139  } else {
140  while (!input_prescale.eof()) {
141  string tmp;
142  getline(input_prescale, tmp, '\n');
143  xmlPayload_prescale.append(tmp);
144  }
145 
146  l1t::XmlConfigParser xmlReader_prescale;
147  l1t::TriggerSystem ts_prescale;
148  ts_prescale.addProcessor("uGtProcessor", "uGtProcessor", "-1", "-1");
149 
150  // run the parser
151  xmlReader_prescale.readDOMFromString(xmlPayload_prescale); // initialize it
152  xmlReader_prescale.readRootElement(ts_prescale, "uGT"); // extract all of the relevant context
153  ts_prescale.setConfigured();
154 
155  const std::map<std::string, l1t::Parameter>& settings_prescale = ts_prescale.getParameters("uGtProcessor");
156  std::map<std::string, unsigned int> prescaleColumns = settings_prescale.at("prescales").getColumnIndices();
157 
158  unsigned int numColumns_prescale = prescaleColumns.size();
159 
160  int NumPrescaleSets = numColumns_prescale - 1;
162  std::vector<unsigned int> algoBits =
163  settings_prescale.at("prescales").getTableColumn<unsigned int>("algo/prescale-index");
164  int NumAlgos_prescale = *std::max_element(algoBits.begin(), algoBits.end()) + 1;
165 
166  if (NumPrescaleSets > 0) {
167  // Fill default prescale set
168  for (int iSet = 0; iSet < NumPrescaleSets; iSet++) {
169  prescales.push_back(std::vector<double>());
170  for (int iBit = 0; iBit < NumAlgos_prescale; ++iBit) {
171  int inputDefaultPrescale = 0; // only prescales that are set in the block below are used
172  prescales[iSet].push_back(inputDefaultPrescale);
173  }
174  }
175 
176  for (auto& col : prescaleColumns) {
177  if (col.second < 1)
178  continue; // we don't care for the algorithms' indicies in 0th column
179  int iSet = col.second - 1;
180  std::vector<double> prescalesForSet =
181  settings_prescale.at("prescales").getTableColumn<double>(col.first.c_str());
182  for (unsigned int row = 0; row < prescalesForSet.size(); row++) {
183  double prescale = prescalesForSet[row];
184  unsigned int algoBit = algoBits[row];
185  prescales[iSet][algoBit] = prescale;
186  }
187  }
188  }
189  }
190  input_prescale.close();
191 
193 
194  // finor mask
195  // set all masks to 1 (unmasked) by default
196  triggerMasks.insert(triggerMasks.end(), m_numberPhysTriggers, 1);
197 
198  std::ifstream input_mask_finor;
199  input_mask_finor.open(m_finormaskFile);
200  if (not m_finormaskFile.empty() and not input_mask_finor) {
201  edm::LogError("L1TGlobalPrescalesVetosFractESProducer")
202  << "\nCould not find finor mask file: " << m_finormaskFile
203  << "\nDeafulting the finor mask for all triggers to 1 (unmasked)";
204  } else {
205  while (!input_mask_finor.eof()) {
206  string tmp;
207  getline(input_mask_finor, tmp, '\n');
208  xmlPayload_mask_finor.append(tmp);
209  }
210 
211  l1t::XmlConfigParser xmlReader_mask_finor;
212  l1t::TriggerSystem ts_mask_finor;
213  ts_mask_finor.addProcessor("uGtProcessor", "uGtProcessor", "-1", "-1");
214 
215  // run the parser
216  xmlReader_mask_finor.readDOMFromString(xmlPayload_mask_finor); // initialize it
217  xmlReader_mask_finor.readRootElement(ts_mask_finor, "uGT"); // extract all of the relevant context
218  ts_mask_finor.setConfigured();
219 
220  const std::map<std::string, l1t::Parameter>& settings_mask_finor = ts_mask_finor.getParameters("uGtProcessor");
221 
222  std::vector<unsigned int> algo_mask_finor =
223  settings_mask_finor.at("finorMask").getTableColumn<unsigned int>("algo");
224  std::vector<unsigned int> mask_mask_finor =
225  settings_mask_finor.at("finorMask").getTableColumn<unsigned int>("mask");
226 
227  for (unsigned int row = 0; row < algo_mask_finor.size(); row++) {
228  unsigned int algoBit = algo_mask_finor[row];
229  unsigned int mask = mask_mask_finor[row];
230  if (algoBit < m_numberPhysTriggers)
231  triggerMasks[algoBit] = mask;
232  }
233  }
234  input_mask_finor.close();
235 
237 
238  // veto mask
239  // Setting veto mask to default 0 (no veto)
240  for (unsigned int iAlg = 0; iAlg < m_numberPhysTriggers; iAlg++)
241  triggerVetoMasks.push_back(0);
242 
243  std::ifstream input_mask_veto;
244  input_mask_veto.open(m_vetomaskFile);
245  if (not m_vetomaskFile.empty() and not input_mask_veto) {
246  edm::LogError("L1TGlobalPrescalesVetosFractESProducer")
247  << "\nCould not find veto mask file: " << m_vetomaskFile
248  << "\nDeafulting the veto mask for all triggers to 1 (unmasked)";
249  } else {
250  while (!input_mask_veto.eof()) {
251  string tmp;
252  getline(input_mask_veto, tmp, '\n');
253  xmlPayload_mask_veto.append(tmp);
254  }
255 
256  l1t::XmlConfigParser xmlReader_mask_veto;
257  l1t::TriggerSystem ts_mask_veto;
258  ts_mask_veto.addProcessor("uGtProcessor", "uGtProcessor", "-1", "-1");
259 
260  // run the parser
261  xmlReader_mask_veto.readDOMFromString(xmlPayload_mask_veto); // initialize it
262  xmlReader_mask_veto.readRootElement(ts_mask_veto, "uGT"); // extract all of the relevant context
263  ts_mask_veto.setConfigured();
264 
265  const std::map<std::string, l1t::Parameter>& settings_mask_veto = ts_mask_veto.getParameters("uGtProcessor");
266  std::vector<unsigned int> algo_mask_veto = settings_mask_veto.at("vetoMask").getTableColumn<unsigned int>("algo");
267  std::vector<unsigned int> veto_mask_veto = settings_mask_veto.at("vetoMask").getTableColumn<unsigned int>("veto");
268 
269  for (unsigned int row = 0; row < algo_mask_veto.size(); row++) {
270  unsigned int algoBit = algo_mask_veto[row];
271  unsigned int veto = veto_mask_veto[row];
272  if (algoBit < m_numberPhysTriggers)
273  triggerVetoMasks[algoBit] = int(veto);
274  }
275  }
276  input_mask_veto.close();
277 
279 
280  // Algo bx mask
281  std::ifstream input_mask_algobx;
282  input_mask_algobx.open(m_algobxmaskFile);
283  if (not m_algobxmaskFile.empty() and not input_mask_algobx) {
284  edm::LogError("L1TGlobalPrescalesVetosFractESProducer")
285  << "\nCould not find bx mask file: " << m_algobxmaskFile << "\nNot filling the bx mask map";
286  } else {
287  while (!input_mask_algobx.eof()) {
288  string tmp;
289  getline(input_mask_algobx, tmp, '\n');
290  xmlPayload_mask_algobx.append(tmp);
291  }
292 
293  l1t::XmlConfigParser xmlReader_mask_algobx;
294  l1t::TriggerSystem ts_mask_algobx;
295  ts_mask_algobx.addProcessor("uGtProcessor", "uGtProcessor", "-1", "-1");
296 
297  // run the parser
298  xmlReader_mask_algobx.readDOMFromString(xmlPayload_mask_algobx); // initialize it
299  xmlReader_mask_algobx.readRootElement(ts_mask_algobx, "uGT"); // extract all of the relevant context
300  ts_mask_algobx.setConfigured();
301 
302  const std::map<std::string, l1t::Parameter>& settings_mask_algobx = ts_mask_algobx.getParameters("uGtProcessor");
303  std::map<std::string, unsigned int> mask_algobx_columns =
304  settings_mask_algobx.at("algorithmBxMask").getColumnIndices();
305  std::vector<unsigned int> bunches =
306  settings_mask_algobx.at("algorithmBxMask").getTableColumn<unsigned int>("bx/algo");
307 
308  unsigned int numCol_mask_algobx = mask_algobx_columns.size();
309 
310  int NumAlgoBitsInMask = numCol_mask_algobx - 1;
311  for (int iBit = 0; iBit < NumAlgoBitsInMask; iBit++) {
312  std::vector<unsigned int> algo =
313  settings_mask_algobx.at("algorithmBxMask").getTableColumn<unsigned int>(std::to_string(iBit).c_str());
314  for (unsigned int bx = 0; bx < bunches.size(); bx++) {
315  if (algo[bx] != unsigned(m_bx_mask_default))
316  triggerAlgoBxMaskAlgoTrig[bunches[bx]].push_back(iBit);
317  }
318  }
319  }
320  input_mask_algobx.close();
321 
322  // Set prescales to zero if masked
323  for (auto& prescale : prescales) {
324  for (unsigned int iBit = 0; iBit < prescale.size(); iBit++) {
325  // Add protection in case prescale table larger than trigger mask size
326  if (iBit >= triggerMasks.size()) {
327  edm::LogWarning("L1TGlobal") << "\nWarning: algoBit in prescale table >= triggerMasks.size() "
328  << "\nWarning: no information on masking bit or not, setting as unmasked "
329  << std::endl;
330  } else {
331  prescale[iBit] *= triggerMasks[iBit];
332  }
333  }
334  }
335 
337  m_initialTriggerMaskAlgoTrig = triggerMasks;
338  m_initialTriggerMaskVetoAlgoTrig = triggerVetoMasks;
339  m_initialTriggerAlgoBxMaskAlgoTrig = triggerAlgoBxMaskAlgoTrig;
340 }
341 
343  // do anything here that needs to be done at desctruction time
344  // (e.g. close files, deallocate resources etc.)
345 }
346 
347 //
348 // member functions
349 //
350 
351 // ------------ method called to produce the data ------------
353  const L1TGlobalPrescalesVetosFractRcd& iRecord) {
354  // configure the helper class parameters via its set funtions, e.g.:
359 
360  if (m_verbosity) {
361  LogDebug("L1TGlobal") << " ====> Prescales table <=== " << std::endl;
362  for (unsigned int ix = 0; ix < m_initialPrescaleFactorsAlgoTrig.size(); ix++) {
363  LogDebug("L1TGlobal") << " Prescale set = " << ix << std::endl;
364  for (unsigned int iy = 0; iy < m_initialPrescaleFactorsAlgoTrig[ix].size(); iy++) {
365  LogDebug("L1TGlobal") << "\t Algo " << iy << ": " << m_initialPrescaleFactorsAlgoTrig[ix][iy] << std::endl;
366  }
367  }
368 
369  LogDebug("L1TGlobal") << " ====> Trigger mask veto <=== " << std::endl;
370  for (unsigned int ix = 0; ix < m_initialTriggerMaskVetoAlgoTrig.size(); ix++) {
371  LogDebug("L1TGlobal") << "\t Algo " << ix << ": " << m_initialTriggerMaskVetoAlgoTrig[ix] << std::endl;
372  }
373 
374  LogDebug("L1TGlobal") << " ====> Algo bx mask <=== " << std::endl;
376  LogDebug("L1TGlobal") << "\t(empty map)" << std::endl;
377  for (auto& it : m_initialTriggerAlgoBxMaskAlgoTrig) {
378  LogDebug("L1TGlobal") << " bx = " << it.first << " : iAlg =";
379  std::vector<int> masked = it.second;
380  for (int& iAlg : masked) {
381  LogDebug("L1TGlobal") << " " << iAlg;
382  }
383  LogDebug("L1TGlobal") << " " << std::endl;
384  }
385  }
386 
387  // Return copy so that we don't give away our owned pointer to framework
388  return std::make_unique<L1TGlobalPrescalesVetosFract>(*data_.getWriteInstance());
389 }
390 
391 //define this as a plug-in
auto setWhatProduced(T *iThis, const es::Label &iLabel={})
Definition: ESProducer.h:166
void setConfigured(bool state=true) noexcept
Definition: TriggerSystem.h:74
T getParameter(std::string const &) const
Definition: ParameterSet.h:307
void setTriggerMaskVeto(std::vector< int > value)
std::vector< std::vector< double > > m_initialPrescaleFactorsAlgoTrig
std::unique_ptr< L1TGlobalPrescalesVetosFract > ReturnType
delete x;
Definition: CaloConfig.h:22
Log< level::Error, false > LogError
std::map< int, std::vector< int > > m_initialTriggerAlgoBxMaskAlgoTrig
static std::string to_string(const XMLCh *ch)
L1TGlobalPrescalesVetosFract * getWriteInstance()
void readDOMFromString(const std::string &str, xercesc::DOMDocument *&doc)
const std::map< std::string, Parameter > & getParameters(const char *processor) const
#define DEFINE_FWK_EVENTSETUP_MODULE(type)
Definition: ModuleFactory.h:61
ALPAKA_FN_ACC ALPAKA_FN_INLINE uint32_t ix(uint32_t id)
void setTriggerAlgoBxMask(std::map< int, std::vector< int > > value)
ReturnType produce(const L1TGlobalPrescalesVetosFractRcd &)
deadvectors [0] push_back({0.0175431, 0.538005, 6.80997, 13.29})
void readRootElement(TriggerSystem &aTriggerSystem, const std::string &sysId="")
HLT enums.
col
Definition: cuy.py:1009
void addProcessor(const char *processor, const char *role, const char *crate, const char *slot)
ALPAKA_FN_ACC ALPAKA_FN_INLINE uint32_t iy(uint32_t id)
const std::string & fullPath() const
Definition: FileInPath.cc:144
Log< level::Warning, false > LogWarning
tmp
align.sh
Definition: createJobs.py:716
void setPrescaleFactorTable(std::vector< std::vector< double > > value)
#define LogDebug(id)