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 () override
 
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, const Pythia8::StringEnd *SE) override
 
bool doReconnectResonanceSystems (int oldSizeEvt, Pythia8::Event &event) override
 
bool doVetoFragmentation (Pythia8::Particle part, const Pythia8::StringEnd *SE) 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 6 of file MultiUserHook.h.

Constructor & Destructor Documentation

MultiUserHook::MultiUserHook ( )
inline

Definition at line 11 of file MultiUserHook.h.

11 {}

Member Function Documentation

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

Definition at line 14 of file MultiUserHook.h.

References hooks_.

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

Definition at line 112 of file MultiUserHook.h.

References hooks_.

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

Definition at line 102 of file MultiUserHook.h.

References hooks_.

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

Definition at line 93 of file MultiUserHook.h.

References hooks_, and run_regression::test.

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

Definition at line 432 of file MultiUserHook.h.

References hooks_, and run_regression::test.

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

Definition at line 399 of file MultiUserHook.h.

References hooks_, and run_regression::test.

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

Definition at line 409 of file MultiUserHook.h.

References hooks_, and run_regression::test.

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

Definition at line 74 of file MultiUserHook.h.

References hooks_, and run_regression::test.

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

Definition at line 377 of file MultiUserHook.h.

References hooks_, and run_regression::test.

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

Definition at line 293 of file MultiUserHook.h.

References hooks_, and run_regression::test.

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

Definition at line 334 of file MultiUserHook.h.

References hooks_, and run_regression::test.

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

Definition at line 313 of file MultiUserHook.h.

References hooks_, and run_regression::test.

313  {
314  bool test = false;
315  for (Pythia8::UserHooks *hook : hooks_) {
316  test |= hook->canVetoISREmission();
317  }
318  return test;
319  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:465
run_regression.test
tuple test
Definition: run_regression.py:386
bool MultiUserHook::canVetoMPIEmission ( )
inlineoverride

Definition at line 357 of file MultiUserHook.h.

References hooks_, and run_regression::test.

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

Definition at line 217 of file MultiUserHook.h.

References hooks_, and run_regression::test.

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

Definition at line 274 of file MultiUserHook.h.

References hooks_, and run_regression::test.

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

Definition at line 244 of file MultiUserHook.h.

References hooks_, and run_regression::test.

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

Definition at line 121 of file MultiUserHook.h.

References hooks_, and run_regression::test.

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

Definition at line 160 of file MultiUserHook.h.

References hooks_, and run_regression::test.

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

Definition at line 140 of file MultiUserHook.h.

References hooks_, and run_regression::test.

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

Definition at line 189 of file MultiUserHook.h.

References hooks_, and run_regression::test.

189  {
190  bool test = false;
191  for (Pythia8::UserHooks *hook : hooks_) {
192  test |= hook->canVetoStep();
193  }
194  return test;
195  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:465
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,
const Pythia8::StringEnd *  SE 
)
inlineoverride

Definition at line 442 of file MultiUserHook.h.

References hooks_, and run_regression::test.

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

Definition at line 390 of file MultiUserHook.h.

References hooks_, and run_regression::test.

390  {
391  bool test = true;
392  for (Pythia8::UserHooks *hook : hooks_) {
393  if (hook->canReconnectResonanceSystems()) test &= hook->doReconnectResonanceSystems(oldSizeEvt,event);
394  }
395  return test;
396  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:465
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,
const Pythia8::StringEnd *  SE 
)
inlineoverride

Definition at line 452 of file MultiUserHook.h.

References hooks_, and run_regression::test.

452  {
453  bool test = false;
454  for (Pythia8::UserHooks *hook : hooks_) {
455  if (hook->canChangeFragPar()) test |= hook->doVetoFragmentation(part, SE);
456  }
457  return test;
458  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:465
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 348 of file MultiUserHook.h.

References hooks_, and run_regression::test.

348  {
349  bool test = false;
350  for (Pythia8::UserHooks *hook : hooks_) {
351  if (hook->canVetoFSREmission()) test |= hook->doVetoFSREmission(sizeOld,event,iSys,inResonance);
352  }
353  return test;
354  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:465
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 325 of file MultiUserHook.h.

References hooks_, and run_regression::test.

325  {
326  bool test = false;
327  for (Pythia8::UserHooks *hook : hooks_) {
328  if (hook->canVetoISREmission()) test |= hook->doVetoISREmission(sizeOld,event,iSys);
329  }
330  return test;
331  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:465
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 368 of file MultiUserHook.h.

References hooks_, and run_regression::test.

368  {
369  bool test = false;
370  for (Pythia8::UserHooks *hook : hooks_) {
371  if (hook->canVetoMPIEmission()) test |= hook->doVetoMPIEmission(sizeOld,event);
372  }
373  return test;
374  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:465
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 235 of file MultiUserHook.h.

References hooks_.

235  {
236  for (Pythia8::UserHooks *hook : hooks_) {
237  if (hook->canVetoMPIStep()) return hook->doVetoMPIStep(nMPI,event);
238  }
239  return false;
240  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:465
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 284 of file MultiUserHook.h.

References hooks_, and run_regression::test.

284  {
285  bool test = false;
286  for (Pythia8::UserHooks *hook : hooks_) {
287  if (hook->canVetoPartonLevel()) test |= hook->doVetoPartonLevel(event);
288  }
289  return test;
290  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:465
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 254 of file MultiUserHook.h.

References hooks_, and run_regression::test.

254  {
255  bool test = false;
256  for (Pythia8::UserHooks *hook : hooks_) {
257  if (hook->canVetoPartonLevelEarly()) test |= hook->doVetoPartonLevelEarly(event);
258  }
259  return test;
260  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:465
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 131 of file MultiUserHook.h.

References hooks_, and run_regression::test.

131  {
132  bool test = false;
133  for (Pythia8::UserHooks *hook : hooks_) {
134  if (hook->canVetoProcessLevel()) test |= hook->doVetoProcessLevel(event);
135  }
136  return test;
137  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:465
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 180 of file MultiUserHook.h.

References hooks_.

180  {
181  for (Pythia8::UserHooks *hook : hooks_) {
182  if (hook->canVetoPT()) return hook->doVetoPT(iPos,event);
183  }
184  return false;
185  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:465
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 150 of file MultiUserHook.h.

References hooks_, and run_regression::test.

150  {
151  bool test = false;
152  for (Pythia8::UserHooks *hook : hooks_) {
153  if (hook->canVetoResonanceDecays()) test |= hook->doVetoResonanceDecays(event);
154  }
155  return test;
156  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:465
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 208 of file MultiUserHook.h.

References hooks_.

208  {
209  for (Pythia8::UserHooks *hook : hooks_) {
210  if (hook->canVetoStep()) return hook->doVetoStep(iPos,nISR,nFSR,event);
211  }
212  return false;
213  }
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:465
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 417 of file MultiUserHook.h.

References hooks_.

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

Definition at line 17 of file MultiUserHook.h.

References hooks_, and run_regression::test.

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

References hooks_.

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

Definition at line 13 of file MultiUserHook.h.

References hooks_.

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

Definition at line 226 of file MultiUserHook.h.

References hooks_.

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

Definition at line 198 of file MultiUserHook.h.

References hooks_.

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

Definition at line 265 of file MultiUserHook.h.

References hooks_, and run_regression::test.

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

Definition at line 305 of file MultiUserHook.h.

References hooks_.

305  {
306  for (Pythia8::UserHooks *hook : hooks_) {
307  if (hook->canSetResonanceScale()) return hook->scaleResonance(iRes,event);
308  }
309  return 0.;
310  };
MultiUserHook::hooks_
std::vector< Pythia8::UserHooks * > hooks_
Definition: MultiUserHook.h:465
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 169 of file MultiUserHook.h.

References hooks_.

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

Definition at line 424 of file MultiUserHook.h.

References hooks_.

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

Member Data Documentation

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

Definition at line 465 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