PYTHIA  8.312
VinciaMergingHooks.h
1 // VinciaMergingHooks.h is a part of the PYTHIA event generator.
2 // Copyright (C) 2024 Torbjorn Sjostrand, Peter Skands.
3 // PYTHIA is licenced under the GNU GPL v2 or later, see COPYING for details.
4 // Please respect the MCnet Guidelines, see GUidELINES for details.
5 
6 // This file was authored by Helen Brooks, Christian T Preuss.
7 
8 #ifndef Pythia8_VinciaMergingHooks_H
9 #define Pythia8_VinciaMergingHooks_H
10 
11 #include "Pythia8/MergingHooks.h"
12 #include "Pythia8/PartonLevel.h"
13 #include "Pythia8/UserHooks.h"
14 #include "Pythia8/VinciaCommon.h"
15 
16 namespace Pythia8 {
17 
18 //==========================================================================
19 
20 // Storage device for multiparticle.
21 
22 struct MultiParticle {
23  vector<int> pidList;
24  vector<int> coltypes;
25  // id, if it has a unique one, otherwise 0.
26  int id;
27  // QED charge,if it has a unique one, otherwise 999.
28  int charge;
29  bool isRes, isFCN;
30 };
31 
32 
33 // Helper structure to identify where to find a given
34 // hard process particle inside HardProcessParticleList.
35 
37  // Increment level for every resonance decay.
38  int level;
39  // Position in vector at a given level.
40  int pos;
41 };
42 
43 
44 //==========================================================================
45 
46 // Class to store information about a particle in the hard process.
47 
50 
51  friend class HardProcessParticleList;
52 
53  public:
54 
55  // Construct from particle data.
56  HardProcessParticle(int idIn, ParticleDataEntryPtr pdata,
57  ParticleLocator locIn, HardProcessParticleList* listPtrIn,
58  vector<ParticleLocator>& mothersIn) :
59  isMultiparticle(false), pid(idIn), multiPtr(nullptr),
60  loc(locIn), listPtr(listPtrIn), mothers(mothersIn) {
61  isResSav = pdata->isResonance(); coltype = pdata->colType(pid);
62  charge = pdata->chargeType(pid); isColSav = coltype != 0;
63  nameSav = pdata->name(pid);}
64 
65  // Construct from multiparticle.
66  HardProcessParticle(string nameIn, const MultiParticle* multiPtrIn,
67  ParticleLocator locIn, HardProcessParticleList * listPtrIn,
68  vector<ParticleLocator> & mothersIn) :
69  isMultiparticle(true), nameSav(nameIn), multiPtr(multiPtrIn),
70  loc(locIn), listPtr(listPtrIn), mothers(mothersIn) {
71  pid = multiPtr->id; charge = multiPtr->charge;
72  isResSav = multiPtr->isRes;
73  coltype = multiPtr->coltypes.size() != 0 ? multiPtr->coltypes.at(0) : 0;
74  isColSav = coltype !=0;}
75 
76  // Check if final.
77  bool isFinal() const {return daughters.size() == 0;}
78 
79  // Check if beam particle.
80  bool isBeam() const {return loc.level == 0;}
81 
82  // Check if intermediate particle.
83  bool isIntermediate() const {return !isBeam() && !isFinal();}
84 
85  // Getter methods.
86  bool isRes() const {return isResSav;}
87  bool isCol() const {return isColSav;}
88  bool isMulti() const { return isMultiparticle;}
89  string name() const {return nameSav;}
90  int id() const {return pid;}
91  int chargeType() const {return charge;}
92  int colType() const {return coltype;}
93  vector<ParticleLocator> getDaughters() const {return daughters;}
94  const MultiParticle* getMulti() const {return multiPtr;}
95 
96  // Print the particle.
97  void print() const;
98 
99  private:
100 
101  bool isMultiparticle;
102  bool isResSav;
103  bool isColSav;
104  string nameSav;
105 
106  // pid and coltype if not multiparticle.
107  int pid;
108  int coltype;
109 
110  // QED charge if it has a unique value (even if multiparticle).
111  int charge;
112 
113  // Pointer to a multiparticle if is one,
114  // null pointer otherwise.
115  const MultiParticle* multiPtr;
116 
117  // Location of this particle - only used by particle list.
118  ParticleLocator loc;
119  // Pointer to the list in which this particle lives.
120  HardProcessParticleList* listPtr;
121 
122  // Location of this particle's mother(s).
123  vector<ParticleLocator> mothers;
124 
125  // Location of this particle's daughter(s).
126  vector<ParticleLocator> daughters;
127 
128 };
129 
130 //==========================================================================
131 
132 // List of hard particles.
133 
135 
136  public:
137 
138  // List the hard particles.
139  void list() const;
140 
141  // Fetch pointers to the beams.
142  pair<HardProcessParticle*, HardProcessParticle*> getBeams() {
143  HardProcessParticle* beamAPtr{nullptr}, *beamBPtr{nullptr};
144  if (!particles.empty() && particles[0].size() == 2) {
145  beamAPtr = &particles[0][0]; beamBPtr = &particles[0][1];}
146  return make_pair(beamAPtr,beamBPtr);}
147 
148  // Fetch pointer to particles at i-th level.
149  vector<HardProcessParticle>* getLevel(int i) {
150  if (particles.find(i) != particles.end()) return &particles[i];
151  else return nullptr;}
152 
153  // Get a single particle, given a location.
155  if (particles.find(loc.level) != particles.end() &&
156  int(particles[loc.level].size()) > loc.pos)
157  return &particles[loc.level].at(loc.pos);
158  return nullptr;}
159 
160  // Add multiparticle to list.
161  ParticleLocator add(int level, string nameIn, const MultiParticle* multiPtr,
162  vector<ParticleLocator>& mothersIn);
163 
164  // Add particle to list from data.
165  ParticleLocator add(int level, int idIn, ParticleDataEntryPtr pdata,
166  vector<ParticleLocator>& mothersIn);
167 
168  // Set daughters of particle at mother location.
169  void setDaughters(ParticleLocator& mother,
170  vector<ParticleLocator>& daughters);
171 
172  // Get the next location.
174  // Does this level exist yet? Create.
175  if (particles.find(level) == particles.end())
176  particles[level] = vector<HardProcessParticle>();
177  ParticleLocator loc; loc.level = level; loc.pos = particles[level].size();
178  return loc;}
179 
180  private:
181 
182  // This is the list of all particles, by level (each nested decay
183  // creates a new level).
184  map<int, vector<HardProcessParticle>> particles;
185 
186 };
187 
188 //==========================================================================
189 
190 // Storage device for containing colour structure of hard process.
191 
193  // Pointers to beam particles.
195  HardProcessParticle* beamB{};
196 
197  // Pointers to coloured partons, leptons and resonances.
198  vector<HardProcessParticle*> coloured;
199  vector<HardProcessParticle*> leptons;
200 
201  // IDs of hadronically decaying resonances.
202  vector<int> resPlusHad;
203  vector<int> resMinusHad;
204  vector<int> resNeutralFCHad;
205  vector<int> resNeutralFNHad;
206 
207  // IDs of leptonically decaying resonances.
208  vector<int> resPlusLep;
209  vector<int> resMinusLep;
210  vector<int> resNeutralFCLep;
211  vector<int> resNeutralFNLep;
212 
213  // IDs of charged undecayed resonances
214  // (only for hard process specification when MergeInResSystems = off).
215  vector<int> resPlusUndecayed;
216  vector<int> resMinusUndecayed;
217  vector<int> resNeutralUndecayed;
218 
219  // Counters for partons (after all col res decayed).
220  int nQQbarPairs{0};
221  int nColoured{0};
222 
223  // Minimum and maximum number of chains associated with beams.
224  int nMinBeamChains{0};
225  int nMaxBeamChains{0};
226 };
227 
228 //==========================================================================
229 
230 // Container for the hard process used in Vincia merging.
231 
233 
234  public:
235 
236  // Constructor.
237  VinciaHardProcess(Logger* loggerPtrIn, int verboseIn, bool resolveDecaysIn,
238  bool doHEFTIn, bool doVBFIn) :
239  verbose(verboseIn), loggerPtr(loggerPtrIn),
240  resolveDecays(resolveDecaysIn), doHEFT(doHEFTIn), doVBF(doVBFIn),
241  isInit(false) {defineMultiparticles();}
242 
243  // Initialise process.
244  void initOnProcess(string process, ParticleData* particleData) override;
245 
246  // Redundant inherited methods - only dummy versions here.
247  void storeCandidates(const Event&, string) override {;}
248  bool matchesAnyOutgoing(int, const Event&) override {return false;}
249  bool findOtherCandidates(int, const Event&, bool) override {return false;}
250 
251  // Print functions.
252  void list() const {parts.list();}
253  void listLookup() const;
254 
255  // Set verbosity.
256  void setVerbose(int verboseIn) {verbose = verboseIn;}
257 
258  // Check if initialised.
259  bool initSuccess() {return isInit;}
260 
261  // Return the colour structure of the hard process.
262  void getColourStructure(ColourStructure& colStructNow);
263 
264 private:
265 
266  // Initialised multiparticle definitions.
267  void defineMultiparticles();
268  // Check if ID may be a beam particle.
269  bool isBeamID(int id);
270  // Initialise map of names to IDs.
271  void initLookup(ParticleData* particleData);
272 
273  // Split process string into incoming, outgoing using ">".
274  bool splitProcess(string process, vector<string>& inWords,
275  vector<string>& outWords);
276  // Split string into words by spaces, and append to the back
277  // (or front) of wordsOut.
278  void splitbyWhitespace(string wordIn, vector<string>& wordsOut,
279  bool atFront = false);
280 
281  // Set the list of particles in the hard process.
282  bool getParticles(ParticleData* particleDataPtr,
283  vector<string> inWords,
284  vector<string> outWords);
285 
286  // Recursive version (if decays are found).
287  bool getParticles(ParticleData* particleDataPtr,
288  vector<string> inWords,
289  vector<string> outWords,
290  int levelNow,
291  vector<ParticleLocator>& mothersIn,
292  vector<ParticleLocator>& mothersNow);
293 
294  // Add a particle to list, and save location in loc if successful.
295  bool addParticle(ParticleData* particleDataPtr,int level, bool isIncoming,
296  string name, vector<ParticleLocator>& mothersIn, ParticleLocator& loc);
297 
298  // Set daughters of particle at mother location.
299  void setDaughters(ParticleLocator& mother,
300  vector<ParticleLocator>& daughters) {parts.setDaughters(mother,daughters);}
301 
302  // Verbosity.
303  int verbose;
304 
305  // Logger object.
306  Logger* loggerPtr{};
307 
308  // Flag to control how resonances are handled.
309  bool resolveDecays;
310 
311  // Flags to control how HEFT and VBF are handled.
312  bool doHEFT, doVBF;
313 
314  // Provide a way to look up a particle data entry by its name.
315  map<string, int> lookupIDfromName;
316 
317  // Store neutral flavour-changing resonances.
318  map<int, bool> isFCNres;
319 
320  // Provide a way to define multparticles.
321  map<string, MultiParticle> multiparticles;
322 
323  // Main way of storing the hard process particles.
325 
326  // Did initialisation succeed?
327  bool isInit;
328 
329 };
330 
331 //==========================================================================
332 
333 // Class for Vincia to perform merging.
334 
336 
337  public:
338 
339  // Constructor.
340  VinciaMergingHooks() : vinHardProcessPtr(nullptr), isInit(false) {;}
341  // Destructor.
342  ~VinciaMergingHooks() {if (hardProcess) delete hardProcess;}
343 
344  // Initialise.
345  void init() override;
346 
347  // Set starting scales.
348  bool setShowerStartingScales(bool isTrial, bool,
349  double& pTscaleIn, const Event& event, double& pTmaxFSRIn, bool&,
350  double& pTmaxISRIn, bool&, double& pTmaxMPIIn, bool&) override;
351 
352  // This MergingHooks is for Vincia only.
353  virtual bool usesVincia() override {return true;}
354 
355  // Calculate merging scale of current state.
356  virtual double tmsNow(const Event& event) override;
357 
358  // Check whether an event should be vetoed due to branching above tMS.
359  virtual bool canVetoStep() override;
360  virtual bool doVetoStep(const Event& process, const Event& event, bool)
361  override;
362 
363  // Overridden base class methods.
364  virtual bool doVetoEmission(const Event&) override {return false;}
365  virtual bool canVetoEmission() override {return false;}
366  virtual double dampenIfFailCuts(const Event& ) override {return 0.;}
367  virtual int getNumberOfClusteringSteps(const Event&, bool) override {
368  return 0;}
369  virtual bool canCutOnRecState() override {return false;}
370  virtual bool doCutOnRecState(const Event&) override {return false;}
371  virtual bool canVetoTrialEmission() override {return false;}
372  virtual bool doVetoTrialEmission(const Event&, const Event&) override {
373  return false;}
374  virtual bool useShowerPlugin() override {return false;}
375  virtual double hardProcessME(const Event&) override {return 0;}
376 
377  // Others.
378  virtual double tmsDefinition( const Event&) override {return 0.;}
379 
380  // Set and get verbosity.
381  void setVerbose(int verboseIn) {verbose = verboseIn;}
382  int getVerbose() {return verbose;}
383 
384  // Check if initialisation succeeded.
385  bool initSuccess() {return isInit;}
386 
387  // Get list of leptons in the hard process.
388  vector<HardProcessParticle*> getLeptons() {return colStructSav.leptons;}
389 
390  // Get number of undecayed resonances.
392  return int(colStructSav.resPlusUndecayed.size());}
393  int getNResMinusUndecayed() {
394  return int(colStructSav.resMinusUndecayed.size());}
395  int getNResNeutralUndecayed() {
396  return int(colStructSav.resNeutralUndecayed.size());}
397 
398  // Get list of undecayed resonances in the hard process.
399  vector<int> getResPlusUndecayed() {
400  return colStructSav.resPlusUndecayed;}
401  vector<int> getResMinusUndecayed() {
402  return colStructSav.resMinusUndecayed;}
403  vector<int> getResNeutralUndecayed() {
404  return colStructSav.resNeutralUndecayed;}
405 
406  // Get list of leptonically decaying resonances in the hard process.
407  vector<int> getResPlusLep() {return colStructSav.resPlusLep;}
408  vector<int> getResMinusLep() {return colStructSav.resMinusLep;}
409  vector<int> getResNeutralFCLep() {return colStructSav.resNeutralFCLep;}
410  vector<int> getResNeutralFNLep() {return colStructSav.resNeutralFNLep;}
411 
412  // Get list of hadronically decaying resonances in the hard process.
413  vector<int> getResPlusHad() {return colStructSav.resPlusHad;}
414  vector<int> getResMinusHad() {return colStructSav.resMinusHad;}
415  vector<int> getResNeutralFCHad() {return colStructSav.resNeutralFCHad;}
416  vector<int> getResNeutralFNHad() {return colStructSav.resNeutralFNHad;}
417 
418  // Get number of hadronically decaying resonances in the hard process.
419  int getNResPlusHad() {return colStructSav.resPlusHad.size();}
420  int getNResMinusHad() {return colStructSav.resMinusHad.size();}
421  int getNResNeutralFCHad() {return colStructSav.resNeutralFCHad.size();}
422  int getNResNeutralFNHad() {return colStructSav.resNeutralFNHad.size();}
423  int getNResHad() {return getNResPlusHad() + getNResMinusHad() +
424  getNResNeutralFCHad() + getNResNeutralFNHad();}
425 
426  // Get numbers of (either hadronically or leptonically decaying)
427  // resonances in the hard process.
428  int getNResPlus() {return colStructSav.resPlusHad.size() +
429  colStructSav.resPlusLep.size();}
430  int getNResMinus() {return colStructSav.resMinusHad.size() +
431  colStructSav.resMinusLep.size();}
432  int getNResNeutralFC() {return colStructSav.resNeutralFCHad.size() +
433  colStructSav.resNeutralFCLep.size();}
434  int getNResNeutralFN() {return colStructSav.resNeutralFNHad.size() +
435  colStructSav.resNeutralFNLep.size();}
436 
437  // Get information about the beam chains.
438  int getNChainsMin() {return colStructSav.nMinBeamChains;}
439  int getNChainsMax() {return colStructSav.nMaxBeamChains;}
440  int getNPartons() {return colStructSav.nColoured;}
441  int getNQPairs() {return colStructSav.nQQbarPairs;}
442 
443  // Get informations about whether colour structure has been set yet.
444  bool hasSetColourStructure() {return hasColStruct;}
445 
446  // Check if we are merging in resonance systems.
447  bool canMergeRes() {return doMergeRes;}
448 
449  // Check if we are merging in VBF system.
450  bool doMergeInVBF() {return doVBF;}
451 
452  // Check if we are allowing HEFT couplings.
453  bool allowHEFT() {return doHEFT;}
454 
455  // Get maximum number of additional jets from resonance decay systems.
456  int nMaxJetsRes() {return nJetMaxResSave;}
457 
458  // Fetch shower restarting scale for resonances.
459  void setScaleRes(int iRes, double scale) {resSysRestartScale[iRes] = scale;}
460 
461  // Fetch shower starting scale for resonances.
462  double getScaleRes(int iRes, const Event&) {
463  return resSysRestartScale.find(iRes) != resSysRestartScale.end() ?
464  resSysRestartScale[iRes] : tmsCut();}
465 
466  // Check if clusterings are allowed.
467  bool canClusFF() {return doFF;}
468  bool canClusRF() {return doRF;}
469  bool canClusII() {return doII;}
470  bool canClusIF() {return doIF;}
471 
472  // Veto showered event if branching is above merging scale.
473  bool isAboveMS(const Event& event);
474 
475  // Same as HardProcess, but explicitly of VinciaHardProcess type.
476  // Note both point to the same object.
477  VinciaHardProcess* vinHardProcessPtr{};
478 
479  protected:
480 
481  // Maximal number of additional jets per resonance system.
483 
484  // Number of resonance systems allowed to produce additional jets.
486 
487  // Flag to decide if we can merge in resonance systems.
489 
490  // Tell Vincia whether to veto emissions from non-resonance systems.
492 
493  // Saved information about resonance restart scales.
494  map<int,double> resSysRestartScale;
495 
496  private:
497 
498  // Merging scale implementations.
499  double kTmin(const Event& event);
500  vector<double> cutsMin(const Event& event);
501 
502  // Find the colour structure of the hard process.
503  ColourStructure getColourStructure();
504  bool setColourStructure();
505  void printColStruct();
506 
507  // Check whether a particle is a resonance decay product.
508  bool isResDecayProd(int iPtcl, const Event& event);
509 
510  // Get list of jets in event record according to jet definition.
511  vector<int> getJetsInEvent(const Event& event);
512 
513  // Did we suceed in initialising?
514  bool isInit;
515 
516  // Verbosity.
517  int verbose;
518 
519  // Colour strucuture of the hard process.
520  bool hasColStruct;
521  ColourStructure colStructSav;
522 
523  // Flags to turn on/off FSR or ISR.
524  bool doFF, doRF, doII, doIF;
525 
526  // Flags to turn on/off specific event topologies.
527  bool doHEFT{false}, doVBF{false};
528 
529 };
530 
531 //==========================================================================
532 
533 // Mini UserHooks class for setting the scale of main shower in
534 // resonance systems (if doing merging in these).
535 
536 class MergeResScaleHook : public UserHooks {
537 
538 public:
539 
540  // Constructor.
541  MergeResScaleHook( MergingHooksPtr mergingHooksPtrIn) {
542  // Cast as a VinciaMergingHooks object.
543  vinMergingHooksPtr
544  = dynamic_pointer_cast<VinciaMergingHooks>(mergingHooksPtrIn);
545  if (vinMergingHooksPtr == nullptr || !vinMergingHooksPtr->initSuccess() )
546  canMergeRes = false;
547  else canMergeRes = vinMergingHooksPtr->canMergeRes();}
548 
549  // Start resonance showers at a scale of m.
550  bool canSetResonanceScale() override {return canMergeRes;}
551  double scaleResonance(int iRes, const Event& event) override {
552  return vinMergingHooksPtr->getScaleRes(iRes,event);}
553 
554  private:
555 
556  bool canMergeRes;
557  shared_ptr<VinciaMergingHooks> vinMergingHooksPtr;
558 
559 };
560 
561 //==========================================================================
562 
563 } // end namespace Pythia8
564 
565 #endif // Pythia8_MergingHooks_H
bool doVetoNotInResSav
Tell Vincia whether to veto emissions from non-resonance systems.
Definition: VinciaMergingHooks.h:491
map< int, double > resSysRestartScale
Saved information about resonance restart scales.
Definition: VinciaMergingHooks.h:494
pair< HardProcessParticle *, HardProcessParticle * > getBeams()
Fetch pointers to the beams.
Definition: VinciaMergingHooks.h:142
int getNResPlusUndecayed()
Get number of undecayed resonances.
Definition: VinciaMergingHooks.h:391
HardProcessParticle * getPart(ParticleLocator loc)
Get a single particle, given a location.
Definition: VinciaMergingHooks.h:154
vector< int > getResPlusLep()
Get list of leptonically decaying resonances in the hard process.
Definition: VinciaMergingHooks.h:407
virtual bool doVetoEmission(const Event &) override
Overridden base class methods.
Definition: VinciaMergingHooks.h:364
int charge
QED charge,if it has a unique one, otherwise 999.
Definition: VinciaMergingHooks.h:28
virtual bool doVetoTrialEmission(const Event &, const Event &) override
Function to check if trial emission should be rejected.
Definition: VinciaMergingHooks.h:372
Definition: VinciaMergingHooks.h:49
The Event class holds all info on the generated event.
Definition: Event.h:453
vector< int > resPlusUndecayed
Definition: VinciaMergingHooks.h:215
int getNResPlusHad()
Get number of hadronically decaying resonances in the hard process.
Definition: VinciaMergingHooks.h:419
bool hasSetColourStructure()
Get informations about whether colour structure has been set yet.
Definition: VinciaMergingHooks.h:444
vector< HardProcessParticle > * getLevel(int i)
Fetch pointer to particles at i-th level.
Definition: VinciaMergingHooks.h:149
virtual bool canVetoEmission() override
Function to allow not counting a trial emission.
Definition: VinciaMergingHooks.h:365
int getNResPlus()
Definition: VinciaMergingHooks.h:428
HardProcessParticle(int idIn, ParticleDataEntryPtr pdata, ParticleLocator locIn, HardProcessParticleList *listPtrIn, vector< ParticleLocator > &mothersIn)
Construct from particle data.
Definition: VinciaMergingHooks.h:56
void setScaleRes(int iRes, double scale)
Fetch shower restarting scale for resonances.
Definition: VinciaMergingHooks.h:459
Definition: VinciaMergingHooks.h:536
vector< HardProcessParticle * > getLeptons()
Get list of leptons in the hard process.
Definition: VinciaMergingHooks.h:388
virtual bool canCutOnRecState() override
Definition: VinciaMergingHooks.h:369
int nJetMaxResSave
Maximal number of additional jets per resonance system.
Definition: VinciaMergingHooks.h:482
virtual double hardProcessME(const Event &) override
Function to calculate the hard process matrix element.
Definition: VinciaMergingHooks.h:375
double scaleResonance(int iRes, const Event &event) override
Definition: VinciaMergingHooks.h:551
vector< int > getResPlusHad()
Get list of hadronically decaying resonances in the hard process.
Definition: VinciaMergingHooks.h:413
bool canClusFF()
Check if clusterings are allowed.
Definition: VinciaMergingHooks.h:467
void list() const
Print functions.
Definition: VinciaMergingHooks.h:252
bool isFinal() const
Check if final.
Definition: VinciaMergingHooks.h:77
vector< int > resPlusHad
IDs of hadronically decaying resonances.
Definition: VinciaMergingHooks.h:202
vector< int > getResPlusUndecayed()
Get list of undecayed resonances in the hard process.
Definition: VinciaMergingHooks.h:399
Definition: Logger.h:23
void setVerbose(int verboseIn)
Set verbosity.
Definition: VinciaMergingHooks.h:256
vector< HardProcessParticle * > coloured
Pointers to coloured partons, leptons and resonances.
Definition: VinciaMergingHooks.h:198
virtual double dampenIfFailCuts(const Event &) override
Definition: VinciaMergingHooks.h:366
bool isIntermediate() const
Check if intermediate particle.
Definition: VinciaMergingHooks.h:83
virtual bool usesVincia() override
This MergingHooks is for Vincia only.
Definition: VinciaMergingHooks.h:353
~VinciaMergingHooks()
Destructor.
Definition: VinciaMergingHooks.h:342
void setVerbose(int verboseIn)
Set and get verbosity.
Definition: VinciaMergingHooks.h:381
bool isBeam() const
Check if beam particle.
Definition: VinciaMergingHooks.h:80
int nMergeResSys
Number of resonance systems allowed to produce additional jets.
Definition: VinciaMergingHooks.h:485
HardProcessParticle(string nameIn, const MultiParticle *multiPtrIn, ParticleLocator locIn, HardProcessParticleList *listPtrIn, vector< ParticleLocator > &mothersIn)
Construct from multiparticle.
Definition: VinciaMergingHooks.h:66
Definition: VinciaMergingHooks.h:36
ParticleLocator getNextLoc(int level)
Get the next location.
Definition: VinciaMergingHooks.h:173
int pos
Position in vector at a given level.
Definition: VinciaMergingHooks.h:40
int getNChainsMin()
Get information about the beam chains.
Definition: VinciaMergingHooks.h:438
void storeCandidates(const Event &, string) override
Redundant inherited methods - only dummy versions here.
Definition: VinciaMergingHooks.h:247
Definition: MergingHooks.h:38
VinciaHardProcess(Logger *loggerPtrIn, int verboseIn, bool resolveDecaysIn, bool doHEFTIn, bool doVBFIn)
Constructor.
Definition: VinciaMergingHooks.h:237
int id
id, if it has a unique one, otherwise 0.
Definition: VinciaMergingHooks.h:26
Class for Vincia to perform merging.
Definition: VinciaMergingHooks.h:335
int nMaxJetsRes()
Get maximum number of additional jets from resonance decay systems.
Definition: VinciaMergingHooks.h:456
Storage device for containing colour structure of hard process.
Definition: VinciaMergingHooks.h:192
bool canMergeRes()
Check if we are merging in resonance systems.
Definition: VinciaMergingHooks.h:447
Storage device for multiparticle.
Definition: VinciaMergingHooks.h:22
bool isRes() const
Getter methods.
Definition: VinciaMergingHooks.h:86
bool matchesAnyOutgoing(int, const Event &) override
Definition: VinciaMergingHooks.h:248
bool doMergeInVBF()
Check if we are merging in VBF system.
Definition: VinciaMergingHooks.h:450
bool initSuccess()
Check if initialised.
Definition: VinciaMergingHooks.h:259
Header for classes to set beam momentum and interaction vertex spread.
Definition: Analysis.h:20
UserHooks is base class for user access to program execution.
Definition: UserHooks.h:32
bool findOtherCandidates(int, const Event &, bool) override
Definition: VinciaMergingHooks.h:249
bool canSetResonanceScale() override
Start resonance showers at a scale of m.
Definition: VinciaMergingHooks.h:550
List of hard particles.
Definition: VinciaMergingHooks.h:134
VinciaMergingHooks()
Constructor.
Definition: VinciaMergingHooks.h:340
virtual double tmsDefinition(const Event &) override
Others.
Definition: VinciaMergingHooks.h:378
bool doMergeRes
Flag to decide if we can merge in resonance systems.
Definition: VinciaMergingHooks.h:488
MergeResScaleHook(MergingHooksPtr mergingHooksPtrIn)
Constructor.
Definition: VinciaMergingHooks.h:541
MergingHooks is base class for user input to the merging procedure.
Definition: MergingHooks.h:166
virtual int getNumberOfClusteringSteps(const Event &, bool) override
Function to return the number of clustering steps for the current event.
Definition: VinciaMergingHooks.h:367
This class holds a map of all ParticleDataEntries.
Definition: ParticleData.h:422
Container for the hard process used in Vincia merging.
Definition: VinciaMergingHooks.h:232
bool allowHEFT()
Check if we are allowing HEFT couplings.
Definition: VinciaMergingHooks.h:453
vector< int > resPlusLep
IDs of leptonically decaying resonances.
Definition: VinciaMergingHooks.h:208
bool initSuccess()
Check if initialisation succeeded.
Definition: VinciaMergingHooks.h:385
virtual bool doCutOnRecState(const Event &) override
Definition: VinciaMergingHooks.h:370
double getScaleRes(int iRes, const Event &)
Fetch shower starting scale for resonances.
Definition: VinciaMergingHooks.h:462
int level
Increment level for every resonance decay.
Definition: VinciaMergingHooks.h:38
virtual bool canVetoTrialEmission() override
Function to allow not counting a trial emission.
Definition: VinciaMergingHooks.h:371