CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
List of all members | Public Member Functions | Private Attributes
MultiUserHook Class Reference

#include <MultiUserHook.h>

Inheritance diagram for MultiUserHook:

Public Member Functions

void addHook (Pythia8::UserHooks *hook)
 
double biasedSelectionWeight () override
 
double biasSelectionBy (const Pythia8::SigmaProcess *sigmaProcessPtr, const Pythia8::PhaseSpace *phaseSpacePtr, bool inEvent) override
 
bool canBiasSelection () override
 
bool canChangeFragPar () override
 
bool canEnhanceEmission () override
 
bool canEnhanceTrial () override
 
bool canModifySigma () override
 
bool canReconnectResonanceSystems () override
 
bool canSetResonanceScale () override
 
bool canVetoFSREmission () override
 
bool canVetoISREmission () override
 
bool canVetoMPIEmission ()
 
bool canVetoMPIStep () override
 
bool canVetoPartonLevel () override
 
bool canVetoPartonLevelEarly () override
 
bool canVetoProcessLevel () override
 
bool canVetoPT () override
 
bool canVetoResonanceDecays () override
 
bool canVetoStep () override
 
bool doChangeFragPar (Pythia8::StringFlav *flavPtr, Pythia8::StringZ *zPtr, Pythia8::StringPT *pTPtr, int idEnd, double m2Had, std::vector< int > iParton) override
 
bool doReconnectResonanceSystems (int oldSizeEvt, Pythia8::Event &event) override
 
bool doVetoFragmentation (Pythia8::Particle part) override
 
bool doVetoFSREmission (int sizeOld, const Pythia8::Event &event, int iSys, bool inResonance=false) override
 
bool doVetoISREmission (int sizeOld, const Pythia8::Event &event, int iSys) override
 
bool doVetoMPIEmission (int sizeOld, const Pythia8::Event &event) override
 
bool doVetoMPIStep (int nMPI, const Pythia8::Event &event) override
 
bool doVetoPartonLevel (const Pythia8::Event &event) override
 
bool doVetoPartonLevelEarly (const Pythia8::Event &event) override
 
bool doVetoProcessLevel (Pythia8::Event &event) override
 
bool doVetoPT (int iPos, const Pythia8::Event &event) override
 
bool doVetoResonanceDecays (Pythia8::Event &event) override
 
bool doVetoStep (int iPos, int nISR, int nFSR, const Pythia8::Event &event) override
 
double enhanceFactor (std::string str) override
 
bool initAfterBeams () override
 
double multiplySigmaBy (const Pythia8::SigmaProcess *sigmaProcessPtr, const Pythia8::PhaseSpace *phaseSpacePtr, bool inEvent) override
 
 MultiUserHook ()
 
unsigned int nHooks () const
 
int numberVetoMPIStep () override
 
int numberVetoStep () override
 
bool retryPartonLevel () override
 
double scaleResonance (int iRes, const Pythia8::Event &event) override
 
double scaleVetoPT () override
 
double vetoProbability (std::string str) override
 

Private Attributes

std::vector< Pythia8::UserHooks * > hooks_
 

Detailed Description

Definition at line 3 of file MultiUserHook.h.

Constructor & Destructor Documentation

MultiUserHook::MultiUserHook ( )
inline

Definition at line 8 of file MultiUserHook.h.

8 {}

Member Function Documentation

void MultiUserHook::addHook ( Pythia8::UserHooks *  hook)
inline

Definition at line 11 of file MultiUserHook.h.

References hooks_.

11 { hooks_.push_back(hook); }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
double MultiUserHook::biasedSelectionWeight ( )
inlineoverride

Definition at line 109 of file MultiUserHook.h.

References hooks_.

109  {
110  double factor = 1.;
111  for (Pythia8::UserHooks *hook : hooks_) {
112  if (hook->canBiasSelection()) factor *= hook->biasedSelectionWeight();
113  }
114  return factor;
115  };
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
double MultiUserHook::biasSelectionBy ( const Pythia8::SigmaProcess *  sigmaProcessPtr,
const Pythia8::PhaseSpace *  phaseSpacePtr,
bool  inEvent 
)
inlineoverride

Definition at line 99 of file MultiUserHook.h.

References hooks_.

100  {
101  double factor = 1.;
102  for (Pythia8::UserHooks *hook : hooks_) {
103  if (hook->canBiasSelection()) factor *= hook->biasSelectionBy(sigmaProcessPtr,phaseSpacePtr,inEvent);
104  }
105  return factor;
106  };
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
bool MultiUserHook::canBiasSelection ( )
inlineoverride

Definition at line 90 of file MultiUserHook.h.

References hooks_, and run_regression::test.

90  {
91  bool test = false;
92  for (Pythia8::UserHooks *hook : hooks_) {
93  test |= hook->canBiasSelection();
94  }
95  return test;
96  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
run_regression.test
tuple test
Definition: run_regression.py:386
bool MultiUserHook::canChangeFragPar ( )
inlineoverride

Definition at line 429 of file MultiUserHook.h.

References hooks_, and run_regression::test.

429  {
430  bool test = false;
431  for (Pythia8::UserHooks *hook : hooks_) {
432  test |= hook->canChangeFragPar();
433  }
434  return test;
435  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
run_regression.test
tuple test
Definition: run_regression.py:386
bool MultiUserHook::canEnhanceEmission ( )
inlineoverride

Definition at line 396 of file MultiUserHook.h.

References hooks_, and run_regression::test.

396  {
397  bool test = false;
398  for (Pythia8::UserHooks *hook : hooks_) {
399  test |= hook->canEnhanceEmission();
400  }
401  return test;
402  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
run_regression.test
tuple test
Definition: run_regression.py:386
bool MultiUserHook::canEnhanceTrial ( )
inlineoverride

Definition at line 406 of file MultiUserHook.h.

References hooks_, and run_regression::test.

406  {
407  bool test = false;
408  for (Pythia8::UserHooks *hook : hooks_) {
409  test |= hook->canEnhanceTrial();
410  }
411  return test;
412  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
run_regression.test
tuple test
Definition: run_regression.py:386
bool MultiUserHook::canModifySigma ( )
inlineoverride

Definition at line 71 of file MultiUserHook.h.

References hooks_, and run_regression::test.

71  {
72  bool test = false;
73  for (Pythia8::UserHooks *hook : hooks_) {
74  test |= hook->canModifySigma();
75  }
76  return test;
77  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
run_regression.test
tuple test
Definition: run_regression.py:386
bool MultiUserHook::canReconnectResonanceSystems ( )
inlineoverride

Definition at line 374 of file MultiUserHook.h.

References hooks_, and run_regression::test.

374  {
375  bool test = false;
376  for (Pythia8::UserHooks *hook : hooks_) {
377  test |= hook->canReconnectResonanceSystems();
378  }
379  return test;
380  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
run_regression.test
tuple test
Definition: run_regression.py:386
bool MultiUserHook::canSetResonanceScale ( )
inlineoverride

Definition at line 290 of file MultiUserHook.h.

References hooks_, and run_regression::test.

290  {
291  bool test = false;
292  for (Pythia8::UserHooks *hook : hooks_) {
293  test |= hook->canSetResonanceScale();
294  }
295  return test;
296  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
run_regression.test
tuple test
Definition: run_regression.py:386
bool MultiUserHook::canVetoFSREmission ( )
inlineoverride

Definition at line 331 of file MultiUserHook.h.

References hooks_, and run_regression::test.

331  {
332  bool test = false;
333  for (Pythia8::UserHooks *hook : hooks_) {
334  test |= hook->canVetoFSREmission();
335  }
336  return test;
337  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
run_regression.test
tuple test
Definition: run_regression.py:386
bool MultiUserHook::canVetoISREmission ( )
inlineoverride

Definition at line 310 of file MultiUserHook.h.

References hooks_, and run_regression::test.

310  {
311  bool test = false;
312  for (Pythia8::UserHooks *hook : hooks_) {
313  test |= hook->canVetoISREmission();
314  }
315  return test;
316  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
run_regression.test
tuple test
Definition: run_regression.py:386
bool MultiUserHook::canVetoMPIEmission ( )
inline

Definition at line 354 of file MultiUserHook.h.

References hooks_, and run_regression::test.

354  {
355  bool test = false;
356  for (Pythia8::UserHooks *hook : hooks_) {
357  test |= hook->canVetoMPIEmission();
358  }
359  return test;
360  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
run_regression.test
tuple test
Definition: run_regression.py:386
bool MultiUserHook::canVetoMPIStep ( )
inlineoverride

Definition at line 214 of file MultiUserHook.h.

References hooks_, and run_regression::test.

214  {
215  bool test = false;
216  for (Pythia8::UserHooks *hook : hooks_) {
217  test |= hook->canVetoMPIStep();
218  }
219  return test;
220  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
run_regression.test
tuple test
Definition: run_regression.py:386
bool MultiUserHook::canVetoPartonLevel ( )
inlineoverride

Definition at line 271 of file MultiUserHook.h.

References hooks_, and run_regression::test.

271  {
272  bool test = false;
273  for (Pythia8::UserHooks *hook : hooks_) {
274  test |= hook->canVetoPartonLevel();
275  }
276  return test;
277  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
run_regression.test
tuple test
Definition: run_regression.py:386
bool MultiUserHook::canVetoPartonLevelEarly ( )
inlineoverride

Definition at line 241 of file MultiUserHook.h.

References hooks_, and run_regression::test.

241  {
242  bool test = false;
243  for (Pythia8::UserHooks *hook : hooks_) {
244  test |= hook->canVetoPartonLevelEarly();
245  }
246  return test;
247  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
run_regression.test
tuple test
Definition: run_regression.py:386
bool MultiUserHook::canVetoProcessLevel ( )
inlineoverride

Definition at line 118 of file MultiUserHook.h.

References hooks_, and run_regression::test.

118  {
119  bool test = false;
120  for (Pythia8::UserHooks *hook : hooks_) {
121  test |= hook->canVetoProcessLevel();
122  }
123  return test;
124  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
run_regression.test
tuple test
Definition: run_regression.py:386
bool MultiUserHook::canVetoPT ( )
inlineoverride

Definition at line 157 of file MultiUserHook.h.

References hooks_, and run_regression::test.

157  {
158  bool test = false;
159  for (Pythia8::UserHooks *hook : hooks_) {
160  test |= hook->canVetoPT();
161  }
162  return test;
163  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
run_regression.test
tuple test
Definition: run_regression.py:386
bool MultiUserHook::canVetoResonanceDecays ( )
inlineoverride

Definition at line 137 of file MultiUserHook.h.

References hooks_, and run_regression::test.

137  {
138  bool test = false;
139  for (Pythia8::UserHooks *hook : hooks_) {
140  test |= hook->canVetoResonanceDecays();
141  }
142  return test;
143  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
run_regression.test
tuple test
Definition: run_regression.py:386
bool MultiUserHook::canVetoStep ( )
inlineoverride

Definition at line 186 of file MultiUserHook.h.

References hooks_, and run_regression::test.

186  {
187  bool test = false;
188  for (Pythia8::UserHooks *hook : hooks_) {
189  test |= hook->canVetoStep();
190  }
191  return test;
192  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
run_regression.test
tuple test
Definition: run_regression.py:386
bool MultiUserHook::doChangeFragPar ( Pythia8::StringFlav *  flavPtr,
Pythia8::StringZ *  zPtr,
Pythia8::StringPT *  pTPtr,
int  idEnd,
double  m2Had,
std::vector< int >  iParton 
)
inlineoverride

Definition at line 439 of file MultiUserHook.h.

References hooks_, and run_regression::test.

440  {
441  bool test = true;
442  for (Pythia8::UserHooks *hook : hooks_) {
443  if (hook->canChangeFragPar()) test &= hook->doChangeFragPar(flavPtr, zPtr, pTPtr, idEnd, m2Had, iParton);
444  }
445  return test;
446  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
run_regression.test
tuple test
Definition: run_regression.py:386
bool MultiUserHook::doReconnectResonanceSystems ( int  oldSizeEvt,
Pythia8::Event &  event 
)
inlineoverride

Definition at line 387 of file MultiUserHook.h.

References hooks_, and run_regression::test.

387  {
388  bool test = true;
389  for (Pythia8::UserHooks *hook : hooks_) {
390  if (hook->canReconnectResonanceSystems()) test &= hook->doReconnectResonanceSystems(oldSizeEvt,event);
391  }
392  return test;
393  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
event
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger but the state exists so we define the behavior If all triggers are the negative crieriion will lead to accepting the event(this again matches the behavior of"!*"before the partial wildcard feature was incorporated).The per-event"cost"of each negative criterion with multiple relevant triggers is about the same as!*was in the past
run_regression.test
tuple test
Definition: run_regression.py:386
bool MultiUserHook::doVetoFragmentation ( Pythia8::Particle  part)
inlineoverride

Definition at line 449 of file MultiUserHook.h.

References hooks_, and run_regression::test.

449  {
450  bool test = false;
451  for (Pythia8::UserHooks *hook : hooks_) {
452  if (hook->canChangeFragPar()) test |= hook->doVetoFragmentation(part);
453  }
454  return test;
455  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
part
part
Definition: HCALResponse.h:20
run_regression.test
tuple test
Definition: run_regression.py:386
bool MultiUserHook::doVetoFSREmission ( int  sizeOld,
const Pythia8::Event &  event,
int  iSys,
bool  inResonance = false 
)
inlineoverride

Definition at line 345 of file MultiUserHook.h.

References hooks_, and run_regression::test.

345  {
346  bool test = false;
347  for (Pythia8::UserHooks *hook : hooks_) {
348  if (hook->canVetoFSREmission()) test |= hook->doVetoFSREmission(sizeOld,event,iSys,inResonance);
349  }
350  return test;
351  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
event
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger but the state exists so we define the behavior If all triggers are the negative crieriion will lead to accepting the event(this again matches the behavior of"!*"before the partial wildcard feature was incorporated).The per-event"cost"of each negative criterion with multiple relevant triggers is about the same as!*was in the past
run_regression.test
tuple test
Definition: run_regression.py:386
bool MultiUserHook::doVetoISREmission ( int  sizeOld,
const Pythia8::Event &  event,
int  iSys 
)
inlineoverride

Definition at line 322 of file MultiUserHook.h.

References hooks_, and run_regression::test.

322  {
323  bool test = false;
324  for (Pythia8::UserHooks *hook : hooks_) {
325  if (hook->canVetoISREmission()) test |= hook->doVetoISREmission(sizeOld,event,iSys);
326  }
327  return test;
328  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
event
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger but the state exists so we define the behavior If all triggers are the negative crieriion will lead to accepting the event(this again matches the behavior of"!*"before the partial wildcard feature was incorporated).The per-event"cost"of each negative criterion with multiple relevant triggers is about the same as!*was in the past
run_regression.test
tuple test
Definition: run_regression.py:386
bool MultiUserHook::doVetoMPIEmission ( int  sizeOld,
const Pythia8::Event &  event 
)
inlineoverride

Definition at line 365 of file MultiUserHook.h.

References hooks_, and run_regression::test.

365  {
366  bool test = false;
367  for (Pythia8::UserHooks *hook : hooks_) {
368  if (hook->canVetoMPIEmission()) test |= hook->doVetoMPIEmission(sizeOld,event);
369  }
370  return test;
371  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
event
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger but the state exists so we define the behavior If all triggers are the negative crieriion will lead to accepting the event(this again matches the behavior of"!*"before the partial wildcard feature was incorporated).The per-event"cost"of each negative criterion with multiple relevant triggers is about the same as!*was in the past
run_regression.test
tuple test
Definition: run_regression.py:386
bool MultiUserHook::doVetoMPIStep ( int  nMPI,
const Pythia8::Event &  event 
)
inlineoverride

Definition at line 232 of file MultiUserHook.h.

References hooks_.

232  {
233  for (Pythia8::UserHooks *hook : hooks_) {
234  if (hook->canVetoMPIStep()) return hook->doVetoMPIStep(nMPI,event);
235  }
236  return false;
237  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
event
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger but the state exists so we define the behavior If all triggers are the negative crieriion will lead to accepting the event(this again matches the behavior of"!*"before the partial wildcard feature was incorporated).The per-event"cost"of each negative criterion with multiple relevant triggers is about the same as!*was in the past
bool MultiUserHook::doVetoPartonLevel ( const Pythia8::Event &  event)
inlineoverride

Definition at line 281 of file MultiUserHook.h.

References hooks_, and run_regression::test.

281  {
282  bool test = false;
283  for (Pythia8::UserHooks *hook : hooks_) {
284  if (hook->canVetoPartonLevel()) test |= hook->doVetoPartonLevel(event);
285  }
286  return test;
287  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
event
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger but the state exists so we define the behavior If all triggers are the negative crieriion will lead to accepting the event(this again matches the behavior of"!*"before the partial wildcard feature was incorporated).The per-event"cost"of each negative criterion with multiple relevant triggers is about the same as!*was in the past
run_regression.test
tuple test
Definition: run_regression.py:386
bool MultiUserHook::doVetoPartonLevelEarly ( const Pythia8::Event &  event)
inlineoverride

Definition at line 251 of file MultiUserHook.h.

References hooks_, and run_regression::test.

251  {
252  bool test = false;
253  for (Pythia8::UserHooks *hook : hooks_) {
254  if (hook->canVetoPartonLevelEarly()) test |= hook->doVetoPartonLevelEarly(event);
255  }
256  return test;
257  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
event
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger but the state exists so we define the behavior If all triggers are the negative crieriion will lead to accepting the event(this again matches the behavior of"!*"before the partial wildcard feature was incorporated).The per-event"cost"of each negative criterion with multiple relevant triggers is about the same as!*was in the past
run_regression.test
tuple test
Definition: run_regression.py:386
bool MultiUserHook::doVetoProcessLevel ( Pythia8::Event &  event)
inlineoverride

Definition at line 128 of file MultiUserHook.h.

References hooks_, and run_regression::test.

128  {
129  bool test = false;
130  for (Pythia8::UserHooks *hook : hooks_) {
131  if (hook->canVetoProcessLevel()) test |= hook->doVetoProcessLevel(event);
132  }
133  return test;
134  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
event
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger but the state exists so we define the behavior If all triggers are the negative crieriion will lead to accepting the event(this again matches the behavior of"!*"before the partial wildcard feature was incorporated).The per-event"cost"of each negative criterion with multiple relevant triggers is about the same as!*was in the past
run_regression.test
tuple test
Definition: run_regression.py:386
bool MultiUserHook::doVetoPT ( int  iPos,
const Pythia8::Event &  event 
)
inlineoverride

Definition at line 177 of file MultiUserHook.h.

References hooks_.

177  {
178  for (Pythia8::UserHooks *hook : hooks_) {
179  if (hook->canVetoPT()) return hook->doVetoPT(iPos,event);
180  }
181  return false;
182  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
event
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger but the state exists so we define the behavior If all triggers are the negative crieriion will lead to accepting the event(this again matches the behavior of"!*"before the partial wildcard feature was incorporated).The per-event"cost"of each negative criterion with multiple relevant triggers is about the same as!*was in the past
bool MultiUserHook::doVetoResonanceDecays ( Pythia8::Event &  event)
inlineoverride

Definition at line 147 of file MultiUserHook.h.

References hooks_, and run_regression::test.

147  {
148  bool test = false;
149  for (Pythia8::UserHooks *hook : hooks_) {
150  if (hook->canVetoResonanceDecays()) test |= hook->doVetoResonanceDecays(event);
151  }
152  return test;
153  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
event
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger but the state exists so we define the behavior If all triggers are the negative crieriion will lead to accepting the event(this again matches the behavior of"!*"before the partial wildcard feature was incorporated).The per-event"cost"of each negative criterion with multiple relevant triggers is about the same as!*was in the past
run_regression.test
tuple test
Definition: run_regression.py:386
bool MultiUserHook::doVetoStep ( int  iPos,
int  nISR,
int  nFSR,
const Pythia8::Event &  event 
)
inlineoverride

Definition at line 205 of file MultiUserHook.h.

References hooks_.

205  {
206  for (Pythia8::UserHooks *hook : hooks_) {
207  if (hook->canVetoStep()) return hook->doVetoStep(iPos,nISR,nFSR,event);
208  }
209  return false;
210  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
event
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger but the state exists so we define the behavior If all triggers are the negative crieriion will lead to accepting the event(this again matches the behavior of"!*"before the partial wildcard feature was incorporated).The per-event"cost"of each negative criterion with multiple relevant triggers is about the same as!*was in the past
double MultiUserHook::enhanceFactor ( std::string  str)
inlineoverride

Definition at line 414 of file MultiUserHook.h.

References hooks_.

414  {
415  for (Pythia8::UserHooks *hook : hooks_) {
416  if (hook->canEnhanceEmission() || hook->canEnhanceTrial()) return hook->enhanceFactor(str);
417  }
418  return 1.;
419  };
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
bool MultiUserHook::initAfterBeams ( )
inlineoverride

Definition at line 14 of file MultiUserHook.h.

References hooks_, and run_regression::test.

14  {
15  bool test = true;
16  for (Pythia8::UserHooks *hook : hooks_) {
17  hook->initPtr(infoPtr, settingsPtr,
18  particleDataPtr, rndmPtr,
19  beamAPtr, beamBPtr,
20  beamPomAPtr, beamPomBPtr,
21  coupSMPtr, partonSystemsPtr,
22  sigmaTotPtr);
23  test &= hook->initAfterBeams();
24  }
25 
26  //Certain types of hooks can only be handled by one UserHook at a time.
27  //Check for this and return an error if needed
28  int nCanVetoPT = 0;
29  int nCanVetoStep = 0;
30  int nCanVetoMPIStep = 0;
31  int nCanSetResonanceScale = 0;
32  int nCanEnhance = 0;
33  for (Pythia8::UserHooks *hook : hooks_) {
34  if (hook->canVetoPT()) ++nCanVetoPT;
35  if (hook->canVetoStep()) ++nCanVetoStep;
36  if (hook->canVetoMPIStep()) ++nCanVetoMPIStep;
37  if (hook->canSetResonanceScale()) ++nCanSetResonanceScale;
38  if (hook->canEnhanceEmission() || hook->canEnhanceTrial()) ++nCanEnhance;
39  }
40 
41  if (nCanVetoPT>1) {
42  infoPtr->errorMsg("Error in MultiUserHook::initAfterBeams "
43  "multiple UserHooks with canVetoPT() not allowed");
44  test = false;
45  }
46  if (nCanVetoStep>1) {
47  infoPtr->errorMsg("Error in MultiUserHook::initAfterBeams "
48  "multiple UserHooks with canVetoStep() not allowed");
49  test = false;
50  }
51  if (nCanVetoMPIStep>1) {
52  infoPtr->errorMsg("Error in MultiUserHook::initAfterBeams "
53  "multiple UserHooks with canVetoMPIStep() not allowed");
54  test = false;
55  }
56  if (nCanSetResonanceScale>1) {
57  infoPtr->errorMsg("Error in MultiUserHook::initAfterBeams "
58  "multiple UserHooks with canSetResonanceScale() not allowed");
59  test = false;
60  }
61  if (nCanEnhance>1) {
62  infoPtr->errorMsg("Error in MultiUserHook::initAfterBeams "
63  "multiple UserHooks with canEnhanceEmission() or canEnhanceTrial() not allowed");
64  test = false;
65  }
66 
67  return test;
68  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
run_regression.test
tuple test
Definition: run_regression.py:386
double MultiUserHook::multiplySigmaBy ( const Pythia8::SigmaProcess *  sigmaProcessPtr,
const Pythia8::PhaseSpace *  phaseSpacePtr,
bool  inEvent 
)
inlineoverride

Definition at line 80 of file MultiUserHook.h.

References hooks_.

81  {
82  double factor = 1.;
83  for (Pythia8::UserHooks *hook : hooks_) {
84  if (hook->canModifySigma()) factor *= hook->multiplySigmaBy(sigmaProcessPtr,phaseSpacePtr,inEvent);
85  }
86  return factor;
87  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
unsigned int MultiUserHook::nHooks ( ) const
inline

Definition at line 10 of file MultiUserHook.h.

References hooks_.

10 { return hooks_.size(); }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
int MultiUserHook::numberVetoMPIStep ( )
inlineoverride

Definition at line 223 of file MultiUserHook.h.

References hooks_.

223  {
224  for (Pythia8::UserHooks *hook : hooks_) {
225  if (hook->canVetoMPIStep()) return hook->numberVetoMPIStep();
226  }
227  return 1;
228  };
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
int MultiUserHook::numberVetoStep ( )
inlineoverride

Definition at line 195 of file MultiUserHook.h.

References hooks_.

195  {
196  for (Pythia8::UserHooks *hook : hooks_) {
197  if (hook->canVetoStep()) return hook->numberVetoStep();
198  }
199  return 1;
200  };
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
bool MultiUserHook::retryPartonLevel ( )
inlineoverride

Definition at line 262 of file MultiUserHook.h.

References hooks_, and run_regression::test.

262  {
263  bool test = false;
264  for (Pythia8::UserHooks *hook : hooks_) {
265  test |= hook->retryPartonLevel();
266  }
267  return test;
268  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
run_regression.test
tuple test
Definition: run_regression.py:386
double MultiUserHook::scaleResonance ( int  iRes,
const Pythia8::Event &  event 
)
inlineoverride

Definition at line 302 of file MultiUserHook.h.

References hooks_.

302  {
303  for (Pythia8::UserHooks *hook : hooks_) {
304  if (hook->canSetResonanceScale()) return hook->scaleResonance(iRes,event);
305  }
306  return 0.;
307  };
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
event
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger but the state exists so we define the behavior If all triggers are the negative crieriion will lead to accepting the event(this again matches the behavior of"!*"before the partial wildcard feature was incorporated).The per-event"cost"of each negative criterion with multiple relevant triggers is about the same as!*was in the past
double MultiUserHook::scaleVetoPT ( )
inlineoverride

Definition at line 166 of file MultiUserHook.h.

References hooks_.

166  {
167  for (Pythia8::UserHooks *hook : hooks_) {
168  if (hook->canVetoPT()) return hook->scaleVetoPT();
169  }
170  return 0.;
171  };
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462
double MultiUserHook::vetoProbability ( std::string  str)
inlineoverride

Definition at line 421 of file MultiUserHook.h.

References hooks_.

421  {
422  for (Pythia8::UserHooks *hook : hooks_) {
423  if (hook->canEnhanceEmission() || hook->canEnhanceTrial()) return hook->vetoProbability(str);
424  }
425  return 0.;
426  };
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:462

Member Data Documentation

std::vector<Pythia8::UserHooks*> MultiUserHook::hooks_
private

Definition at line 462 of file MultiUserHook.h.

Referenced by addHook(), biasedSelectionWeight(), biasSelectionBy(), canBiasSelection(), canChangeFragPar(), canEnhanceEmission(), canEnhanceTrial(), canModifySigma(), canReconnectResonanceSystems(), canSetResonanceScale(), canVetoFSREmission(), canVetoISREmission(), canVetoMPIEmission(), canVetoMPIStep(), canVetoPartonLevel(), canVetoPartonLevelEarly(), canVetoProcessLevel(), canVetoPT(), canVetoResonanceDecays(), canVetoStep(), doChangeFragPar(), doReconnectResonanceSystems(), doVetoFragmentation(), doVetoFSREmission(), doVetoISREmission(), doVetoMPIEmission(), doVetoMPIStep(), doVetoPartonLevel(), doVetoPartonLevelEarly(), doVetoProcessLevel(), doVetoPT(), doVetoResonanceDecays(), doVetoStep(), enhanceFactor(), initAfterBeams(), multiplySigmaBy(), nHooks(), numberVetoMPIStep(), numberVetoStep(), retryPartonLevel(), scaleResonance(), scaleVetoPT(), and vetoProbability().

Generated for CMSSW Reference Manual by doxygen 1.8.5