PYTHIA  8.303
HIUserHooks.h
1 // HIUserHooks.h is a part of the PYTHIA event generator.
2 // Copyright (C) 2020 Torbjorn Sjostrand.
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 contains the definition of the HIUserHooks class and a
7 // set of other classes used inside Pythia8 to model collisions
8 // involving heavy ions.
9 // Nucleon: represents a proton or a neutron inside a necleus.
10 // SubCollision: a collision between a projectile and a target Nucleon.
11 // NucleusModel: models the Nucleon distribution in a nucleus.
12 // WoodsSaxonModel: NucleusModel implementing a simple Woods-Saxon.
13 // GLISSANDOModel: NucleusModel implementing the GLISSANDO prescription.
14 // ImpactParameterGenerator: distributes nuclei in impact parameter space.
15 // SubCollisionModel: Models the collision probabilities of nucleons.
16 // NaiveSubCollisionModel: A very simple SubCollisionModel.
17 // DoubleStrikman: A more advanced SubCollisionModel.
18 // EventInfo: stores full nucleon-nucleon events with corresponding Info.
19 // HIInfo: info about a Heavy Ion run and its produced events.
20 // HIUserHooks: User hooks for HeavyIons models.
21 
22 #ifndef Pythia8_HIUserHooks_H
23 #define Pythia8_HIUserHooks_H
24 
25 #include "Pythia8/Pythia.h"
26 #include <limits>
27 
28 namespace Pythia8 {
29 
30 class Pythia;
31 
32 // Forward declaration.
33 class EventInfo;
34 
35 //==========================================================================
36 
37 // The HIUnits namespace defines the unitsystem used by the heavy ion
38 // machinery in Pythia8. In particular all lengths are in femtometer
39 // and cross sections are therefore in squared femtometer.
40 namespace HIUnits {
41 
42 // Lengths
43 const double femtometer = 1.0;
44 const double millimeter = 1.0e12;
45 
46 // Cross sections
47 const double femtometer2 = 1.0;
48 const double millibarn = 0.1;
49 const double nanobarn = 1.0e-7;
50 
51 }
52 
53 using namespace HIUnits;
54 
55 //==========================================================================
56 
57 // The Nucleon class represent a nucleon in a nucleus. It has an id
58 // number (proton or neutron) an impact parameter position (absolute
59 // and relative to the nucleus center), a status and a state to be
60 // defined and used by a SubCollisionModel.
61 
62 class Nucleon {
63 
64  friend class SubCollisionModel;
65 
66 public:
67 
68  // Enum for specifying the status of a nucleon.
69  enum Status {
70  UNWOUNDED = 0, //< The nucleon is not wounded.
71  ELASTIC = 1, //< The nucleon is elastically scattered.
72  DIFF = 2, //< The nucleon is diffractively wounded.
73  ABS = 3 //< The nucleon is absorptively wounded.
74  };
75 
76  // The state of a nucleon is a general vector of doubles.
77  typedef vector<double> State;
78 
79  // The constuctor takes a particle id and a position in impact
80  // parameter relative to the nucleus center as arguments.
81  Nucleon(int idIn = 0, int indexIn = 0, const Vec4 & pos = Vec4())
82  : idSave(idIn), indexSave(indexIn), nPosSave(pos), bPosSave(pos),
83  statusSave(UNWOUNDED),eventp(0), isDone(0) {}
84 
85  // Accessor functions:
86 
87  // The nucleon type.
88  int id() const { return idSave; }
89 
90  // The nucleon type.
91  int index() const { return indexSave; }
92 
93  // The position of this nucleon relative to the nucleus center.
94  const Vec4 & nPos() const { return nPosSave; }
95 
96  // The absolute position in impact parameter space.
97  const Vec4 & bPos() const { return bPosSave; }
98 
99  // Shift the absolute position in impact parameter space.
100  const Vec4 & bShift(const Vec4 & bvec) { return bPosSave += bvec; }
101 
102  // The status.
103  Status status() const { return statusSave; }
104 
105  // Check if nucleon has been assigned.
106  bool done() const { return isDone; }
107 
108  // The event this nucleon is assigned to.
109  EventInfo * event() const { return eventp; }
110 
111  // The physical state of the incoming nucleon.
112  const State & state() const { return stateSave; }
113 
114  // Return an alternative state.
115  const State & altState(int i = 0) {
116  static State nullstate;
117  return i < int(altStatesSave.size())? altStatesSave[i]: nullstate;
118  }
119 
120  // Manipulating functions:
121 
122  // Set the status.
123  void status(Status s) { statusSave = s; }
124 
125  // Set the physical state.
126  void state(State s) { stateSave = s; }
127 
128  // Add an alternative state.
129  void addAltState(State s) { altStatesSave.push_back(s); }
130 
131  // Select an event for this nucleon.
132  void select(EventInfo & evp, Status s) {
133  eventp = &evp;
134  isDone = true;
135  status(s);
136  }
137 
138  // Select this nucleon to be assigned to an event.
139  void select() { isDone = true; }
140 
141  // Print out debugging information.
142  void debug();
143 
144 private:
145 
146  // The type of nucleon.
147  int idSave;
148 
149  // The index of this nucleon.
150  int indexSave;
151 
152  // The position in impact parameter relative to the nucleus center.
153  Vec4 nPosSave;
154 
155  // The absolute position in impact parameter.
156  Vec4 bPosSave;
157 
158  // The status.
159  Status statusSave;
160 
161  // The state of this nucleon.
162  State stateSave;
163 
164  // Alternative states to be used to understand fluctuations in the
165  // state of this nucleon.
166  vector<State> altStatesSave;
167 
168  // Pointer to the even this nucleon ends up in.
169  EventInfo * eventp;
170 
171  // True if this nuclein has been assigned to an event.
172  bool isDone;
173 
174  // Reset the states and status.
175  void reset() {
176  statusSave = UNWOUNDED;
177  altStatesSave.clear();
178  bPosSave = nPosSave;
179  isDone = false;
180  eventp = 0;
181  }
182 
183 };
184 
185 //==========================================================================
186 
187 // SubCollision represents a possible collision between a projectile
188 // and a target Nucleon.
189 
191 
192 public:
193 
194  // This defines the type of a bunary nucleon collison.
195  enum Type {
196  NONE, //< This is not a collision.
197  ELASTIC, //< This is an elastic scattering
198  SDEP, //< The projectile is diffractively excited.
199  SDET, //< The target is diffractively excited.
200  DDE, //< Both projectile and target are diffractively excited.
201  CDE, //< Both excited but with central diffraction.
202  ABS //< This is an absorptive (non-diffractive) collision.
203  };
204 
205  SubCollision(Nucleon & projIn, Nucleon & targIn,
206  double bIn, double bpIn, Type typeIn)
207  : proj(&projIn), targ(&targIn), b(bIn), bp(bpIn), type(typeIn) {}
208 
209  SubCollision()
210  : proj(0), targ(0), b(0.0), bp(0.0), type(NONE) {}
211 
212  // Used to order sub-collisions in a set.
213  bool operator< (const SubCollision & s) const { return b < s.b; }
214 
215  // Return 0 if neither proj or target are neutrons, 1 if target is
216  // neutron, 2 if projectile is neutron, and 3 if both are neutrons.
217  int nucleons() const {
218  return ( abs(targ->id()) == 2112? 1: 0 ) +
219  ( abs(proj->id()) == 2112? 2: 0 );
220  }
221 
222  // The projectile nucleon.
224 
225  // The target nucleon.
227 
228  // The impact parameter distance between the nucleons in femtometer.
229  double b;
230 
231  // The impact parameter distance between the nucleons scaled like
232  // in Pythia to have unit average for non-diffractive collisions.
233  double bp;
234 
235  // The type of collison.
236  mutable Type type;
237 
238 };
239 
240 //==========================================================================
241 
242 // This class generates the impact parameter distribution of nucleons
243 // in a nucleus.
244 
246 
247 public:
248 
249  // Default constructor giving the nucleis id and an optional
250  // raduis (in femtometer).
252  : idSave(0), ISave(0), ASave(0), ZSave(0), LSave(0), RSave(0.0),
253  settingsPtr(0), particleDataPtr(0), rndPtr(0) {}
254 
255  // Virtual destructor.
256  virtual ~NucleusModel() {}
257 
258  // Init method.
259  void initPtr(int idIn, Settings & settingsIn,
260  ParticleData & particleDataIn, Rndm & rndIn);
261  virtual bool init();
262 
263  virtual Particle produceIon(bool istarg);
264 
265  // Generate a vector of nucleons according to the implemented model
266  // for a nucleus given by the PDG number.
267  virtual vector<Nucleon> generate() const = 0;
268 
269  // Accessor functions.
270  int id() const { return idSave; }
271  int I() const { return ISave; }
272  int A() const { return ASave; }
273  int Z() const { return ZSave; }
274  int L() const { return LSave; }
275  double R() const { return RSave; }
276 
277 protected:
278 
279  // The nucleus.
280  int idSave;
281 
282  // Cache information about the nucleus.
283  int ISave, ASave, ZSave, LSave;
284 
285  // The estimate of the nucleus radius.
286  double RSave;
287 
288  // Pointers to useful objects.
290  ParticleData * particleDataPtr;
291  Rndm * rndPtr;
292 
293 };
294 
295 //==========================================================================
296 
297 // A general Woods-Saxon distributed nucleus.
298 
300 
301 public:
302 
303  // The default constructor needs a nucleus id, a radius, R, and a
304  // "skin width", a (both length in femtometers).
305  WoodsSaxonModel(): aSave(0.0), intlo(0.0),
306  inthi0(0.0), inthi1(0.0), inthi2(0.0) {}
307 
308  // Accessor functions:
309  double a() const { return aSave; }
310 
311 protected:
312 
313  // Generate the position of a single nucleon. (The time component
314  // is always zero).
315  Vec4 generateNucleon() const;
316 
317  // Virtual destructor.
318  virtual ~WoodsSaxonModel() {}
319 
320  // Setup the generation with a given nucleus radius, R, and a "skin
321  // width", a (both length in femtometers).
322  virtual bool init() {
323  intlo = R()*R()*R()/3.0;
324  inthi0 = a()*R()*R();
325  inthi1 = 2.0*a()*a()*R();
326  inthi2 = 2.0*a()*a()*a();
327  return NucleusModel::init();
328  }
329 
330 protected:
331 
332  // The nucleus radius, skin depth parameter, and hard core nucleon
333  // radius..
334  double aSave;
335 
336 private:
337 
338  // Cashed integrals over the different parts of the over estimating
339  // functions.
340  double intlo, inthi0, inthi1, inthi2;
341 
342 };
343 
344 
345 //==========================================================================
346 
347 // The GLISSANDOModel has a specific parameteraization of a
348 // Wood-Saxon potential for A>16 and is described in asXiv:1310.5475
349 // [nucl-th].
350 
352 
353 public:
354 
355  // Default constructor.
356  GLISSANDOModel(): RhSave(0.0), gaussHardCore(false) {}
357 
358  // Virtual destructor.
359  virtual ~GLISSANDOModel() {}
360 
361  // Initialize.
362  bool init();
363 
364  // Generate a vector of nucleons according to the implemented model
365  // for a nucleus given by the PDG number.
366  virtual vector<Nucleon> generate() const;
367 
368  // Accessor functions.
369  double Rh() const { return RhSave; }
370 
371  double RhGauss() const { return RhSave*abs(rndPtr->gauss()); };
372 
373 private:
374 
375  // The hard core radius;
376  double RhSave;
377 
378  // Option to use a Gaussian hard core instead of a sharp one.
379  bool gaussHardCore;
380 
381 };
382 
383 //==========================================================================
384 
385 // Forward Declarations
386 class SubCollisionModel;
387 class NucleusModel;
388 
389 // ImpactParameterGenerator is able to generate a specific impact
390 // parameter together with a weight such that aweighted average over
391 // any quantity X(b) corresponds to the infinite integral over d^2b
392 // X(b). This base class gives a Gaussian profile, d^2b exp(-b^2/2w^2).
393 
395 
396 public:
397 
398  // The default constructor takes a gneral width (in femtometers) as
399  // argument.
401  : widthSave(0.0), collPtr(0), projPtr(0), targPtr(0),
402  settingsPtr(0), rndPtr(0) {}
403 
404  // Virtual destructor.
406 
407  // Virtual init method.
408  virtual bool init();
409  void initPtr(SubCollisionModel & collIn,
410  NucleusModel & projIn,
411  NucleusModel & targIn,
412  Settings & settingsIn,
413  Rndm & rndIn);
414 
415  // Return a new impact parameter and set the corresponding weight
416  // provided.
417  virtual Vec4 generate(double & weight) const;
418 
419  // Set the width (in femtometers).
420  void width(double widthIn) { widthSave = widthIn; }
421 
422  // Get the width.
423  double width() const { return widthSave; }
424 
425 private:
426 
427  // The width of a distribution.
428  double widthSave;
429 
430 protected:
431 
432  // Info from the controlling HeavyIons object
434  NucleusModel * projPtr;
435  NucleusModel * targPtr;
436  Settings * settingsPtr;
437  Rndm * rndPtr;
438 
439 };
440 
441 
442 //==========================================================================
443 
444 // The SubCollisionModel is is able to model the collision between two
445 // nucleons to tell which type of collision has occurred. The model
446 // may manipulate the corresponing state of the nucleons.
447 
449 
450 public:
451 
452  // Internal class to report cross section estimates.
453  struct SigEst {
454  // The cross sections (tot, nd, dd, sdp, sdt, cd, el, bslope).
455  vector<double> sig;
456 
457  // The extimated error (squared)
458  vector<double> dsig2;
459 
460  // Which cross sections were actually fitted
461  vector<bool> fsig;
462 
463  // The estimate of the average (and squared error) impact
464  // parameter for inelastic non-diffractive collisions.
465  double avNDb, davNDb2;
466 
467  // Constructor for zeros.
468  SigEst(): sig(8, 0.0), dsig2(8, 0.0), fsig(8, false),
469  avNDb(0.0), davNDb2(0.0) {}
470 
471  };
472 
473 public:
474 
475  // The default constructor is empty.
476  SubCollisionModel(): sigTarg(8, 0.0), sigErr(8, 0.05), NInt(100000),
477  NGen(20), NPop(20), sigFuzz(0.2), fitPrint(true), avNDb(1.0*femtometer),
478  projPtr(), targPtr(), sigTotPtr(), settingsPtr(), infoPtr(), rndPtr() {}
479 
480  // Virtual destructor,
481  virtual ~SubCollisionModel() {}
482 
483  // Virtual init method.
484  virtual bool init();
485 
486  void initPtr(NucleusModel & projIn, NucleusModel & targIn,
487  SigmaTotal & sigTotIn, Settings & settingsIn,
488  Info & infoIn, Rndm & rndIn) {
489  projPtr = &projIn;
490  targPtr = &targIn;
491  sigTotPtr = &sigTotIn;
492  settingsPtr = &settingsIn;
493  infoPtr = &infoIn;
494  rndPtr = & rndIn;
495  }
496 
497  // Take two vectors of Nucleons and an impact parameter vector and
498  // produce the corrsponding sub-collisions. Note that states of the
499  // nucleons may be changed. The function in this abstract base
500  // class will reset the nucleon states for convenience. The
501  // sub-collisions are ordered in the impact parameter distance
502  // between the nucleons. The T-variable will be set to the summed
503  // elastic amplityde.
504  virtual multiset<SubCollision> getCollisions(vector<Nucleon> & proj,
505  vector<Nucleon> & targ,
506  const Vec4 & bvec,
507  double & T) = 0;
508 
509  // Access the nucleon-nucleon cross sections assumed
510  // for this model.
511 
512  // The total cross section.
513  double sigTot() const {
514  return sigTarg[0];
515  }
516 
517  // The total cross section.
518  double sigEl() const { return sigTarg[6]; }
519 
520  // The central diffractive excitation cross section.
521  double sigCDE() const { return sigTarg[5]; }
522 
523  // The single diffractive excitation cross section (both sides summed).
524  double sigSDE() const { return sigTarg[3] + sigTarg[4]; }
525 
526  // The single diffractive excitation cross section (excited projectile).
527  double sigSDEP() const { return sigTarg[3]; }
528 
529  // The single diffractive excitation cross section (excited target).
530  double sigSDET() const { return sigTarg[4]; }
531 
532  // The double diffractive excitation cross section.
533  double sigDDE() const { return sigTarg[2]; }
534 
535  // The non-diffractive (absorptive) cross section.
536  double sigND() const { return sigTarg[1]; }
537 
538  // The elastic b-slope parameter.
539  double bSlope() const { return sigTarg[7]; }
540 
541  // Calculate the cross sections for the given set of parameters.
542  virtual SigEst getSig() const {
543  return SigEst();
544  }
545 
546  // Return the average non-diffractive impact parameter.
547  double avNDB() const {
548  return avNDb;
549  }
550 
551  // Calculate the Chi2 for the given cross section estimates.
552  double Chi2(const SigEst & sigs, int npar) const;
553 
554  // Use a simlified genetic algorithm to fit the parameters.
555  virtual bool evolve();
556 
557  // Set the parameters of this model.
558  virtual void setParm(const vector<double> &) {}
559 
560  // Return the current parameters and the minimum and maximum
561  // allowed values for the parameters of this model.
562  virtual vector<double> getParm() const {
563  return vector<double>();
564  }
565  virtual vector<double> minParm() const {
566  return vector<double>();
567  }
568  virtual vector<double> maxParm() const {
569  return vector<double>();
570  }
571 
572 private:
573 
574  // The nucleon-nucleon cross sections targets for this model
575  // (tot, nd, dd, sdp, sdt, cd, el, bslope) and the required precision.
576  vector<double> sigTarg, sigErr;
577 
578 protected:
579 
580  // The parameters stearing the fitting of internal parameters to
581  // the different nucleon-nucleon cross sections.
582  int NInt, NGen, NPop;
583  double sigFuzz;
584  bool fitPrint;
585 
586  // The estimated average impact parameter distance (in femtometer)
587  // for absorptive collisions.
588  double avNDb;
589 
590  // Info from the controlling HeavyIons object
592  NucleusModel * targPtr;
593  SigmaTotal * sigTotPtr;
594  Settings * settingsPtr;
595  Info * infoPtr;
596  Rndm * rndPtr;
597 
598 };
599 
600 
601 //==========================================================================
602 
603 // The most naive sub-collision model, asuming static nucleons and
604 // the absorptive cross section equal to the total inelastic. No
605 // fluctuations, meaning no diffraction.
606 
608 
609 public:
610 
611  // The default constructor simply lists the nucleon-nucleon cross
612  // sections.
614 
615  // Virtual destructor,
617 
618  // Take two vectors of Nucleons and an impact parameter vector and
619  // produce the corrsponding sub-collisions. Note that states of the
620  // nucleons may be changed.
621  virtual multiset<SubCollision>
622  getCollisions(vector<Nucleon> & proj, vector<Nucleon> & targ,
623  const Vec4 & bvec, double & T);
624 
625 };
626 
627 //==========================================================================
628 
629 // A very simple sub-collision model, asuming static nucleons and
630 // just assuring that the individual nucleon-nucleon cross sections
631 // are preserved.
632 
634 
635 public:
636 
637  // The default constructor simply lists the nucleon-nucleon cross
638  // sections.
640 
641  // Virtual destructor,
643 
644  // Take two vectors of Nucleons and an impact parameter vector and
645  // produce the corrsponding sub-collisions. Note that states of the
646  // nucleons may be changed.
647  virtual multiset<SubCollision>
648  getCollisions(vector<Nucleon> & proj, vector<Nucleon> & targ,
649  const Vec4 & bvec, double & T);
650 
651 };
652 
653 //==========================================================================
654 
655 // A more complicated model where each nucleon has a fluctuating
656 // "radius" according to a Strikman-inspired distribution.
657 
659 
660 public:
661 
662  // The default constructor simply lists the nucleon-nucleon cross
663  // sections.
664  DoubleStrikman(int modein = 0)
665  : r0(0.0), k0(4.0), sigd(75.0), alpha(0.5), opacityMode(modein) {}
666 
667  // Virtual destructor,
668  virtual ~DoubleStrikman() {}
669 
670  // Take two vectors of Nucleons and an impact parameter vector and
671  // produce the corrsponding sub-collisions. Note that states of the
672  // nucleons may be changed.
673  virtual multiset<SubCollision>
674  getCollisions(vector<Nucleon> & proj, vector<Nucleon> & targ,
675  const Vec4 & bvec, double & T);
676 
677  // Generate a random number according to a Gamma-distribution.
678  double gamma() const;
679 
680  // The opacity of the collision at a given sigma.
681  double opacity(double sig) const {
682  // *** THINK *** maybe sig/sigd?
683  sig /= sigd;
684  if ( opacityMode == 1 ) sig = 1.0/sig;
685  return sig > std::numeric_limits<double>::epsilon()?
686  pow(-expm1(-1.0/sig), alpha): 1.0;
687  }
688 
689  // Return the elastic amplitude for a projectile and target state
690  // and the impact parameter between the corresponding nucleons.
691  double Tpt(const Nucleon::State & p,
692  const Nucleon::State & t, double b) const {
693  double sig = M_PI*pow2(p[0] + t[0]);
694  double grey = opacity(sig);
695  return sig/grey > b*b*2.0*M_PI? grey: 0.0;
696  }
697 
698  // Calculate the cross sections for the given set of parameters.
699  SigEst getSig() const;
700 
701  // Set the parameters of this model.
702  virtual void setParm(const vector<double> &);
703 
704  // Return the current parameters and the minimum and maximum
705  // allowed values for the parameters of this model.
706  virtual vector<double> getParm() const;
707  virtual vector<double> minParm() const;
708  virtual vector<double> maxParm() const;
709 
710  // Helper functions
711  static void shuffle(double PND1, double PND2,
712  double & PW1, double & PW2);
713  static void shuffel(double & PEL11, double P11,
714  double P12, double P21, double P22);
715  static double PNW(double PWp, double PWt, double PND) {
716  return ( 1.0 - PWp <= 0.0 || 1.0 - PWt <= 0.0 )?
717  0.0: (1.0 - PWp)*(1.0 - PWt)/(1.0 - PND);
718  }
719 
720 protected:
721 
722  // The average radius of the nucleon.
723  double r0;
724 
725  // The power in the Gamma distribution.
726  double k0;
727 
728  // Saturation scale of the nucleus.
729  double sigd;
730 
731  // Power of the saturation scale
732  double alpha;
733 
734  // Optional mode for opacity.
736 
737 };
738 
739 
740 //==========================================================================
741 
742 // A more complicated model where each nucleon has a fluctuating
743 // "radius" according to a Strikman-inspired distribution.
744 
746 
747 public:
748 
749  // The default constructor simply lists the nucleon-nucleon cross
750  // sections.
751  MultiRadial(int NrIn = 0)
752  : Nr(max(1, NrIn)) {
753  dR = T0 = c = phi = vector<double>(Nr, 0.0);
754  }
755 
756  // Virtual destructor,
757  virtual ~MultiRadial() {}
758 
759  // Take two vectors of Nucleons and an impact parameter vector and
760  // produce the corrsponding sub-collisions. Note that states of the
761  // nucleons may be changed.
762  virtual multiset<SubCollision>
763  getCollisions(vector<Nucleon> & proj, vector<Nucleon> & targ,
764  const Vec4 & bvec, double & T);
765 
766  // Return the elastic amplitude for a projectile and target state
767  // and the impact parameter between the corresponding nucleons.
768  double Tpt(const Nucleon::State & p,
769  const Nucleon::State & t, double b) const {
770  return b < p[0] + t[0]? p[1]*t[1]: 0.0;
771  }
772 
773  // Calculate the cross sections for the given set of parameters.
774  SigEst getSig() const;
775 
776  // Set the parameters of this model.
777  virtual void setParm(const vector<double> &);
778 
779  // Return the current parameters and the minimum and maximum
780  // allowed values for the parameters of this model.
781  virtual vector<double> getParm() const;
782  virtual vector<double> minParm() const;
783  virtual vector<double> maxParm() const;
784 
785 protected:
786 
787  // Set the probabilities according to the angle parameters.
788  void setProbs();
789 
790  // Choose a radius.
791  int choose() const;
792 
793  // The number of radii.
794  int Nr;
795 
796 
797  // The probability distribution.
798  vector<double> c;
799 
800  // The difference between radii.
801  vector<double> dR;
802 
803  // The opacity for different radii.
804  vector<double> T0;
805 
806  // The angles defining the probability distribution for the radii.
807  vector<double> phi;
808 
809 };
810 
811 
812 //==========================================================================
813 
814 // Class for storing Events and Info objects.
815 
816 class EventInfo {
817 
818 public:
819 
820  // Empty constructor.
821  EventInfo(): code(0), ordering(-1.0), coll(0), ok(false) {}
822 
823  // The Event object.
825 
826  // The corresponding Info object.
828 
829  // The code for the subprocess.
830  int code;
831 
832  // The ordering variable of this event.
833  double ordering;
834  bool operator<(const EventInfo & ei) const {
835  return ordering < ei.ordering;
836  }
837 
838  // The associated SubCollision object.
840 
841  // Is the event properly generated?
842  bool ok;
843 
844  // Which projectile and target nucleons are included and where are
845  // they placed?
846  map<Nucleon *, pair<int,int> > projs, targs;
847 
848 };
849 
850 //==========================================================================
851 
852 // Class for collecting info about a Heavy Ion run and its produced
853 // events.
854 
855 class HIInfo {
856 
857 public:
858 
859  friend class HeavyIons;
860  friend class Angantyr;
861 
862  // Constructor.
864  : idProjSave(0), idTargSave(0), bSave(0.0), NSave(0), NAccSave(0),
865  sigmaTotSave(0.0), sigmaNDSave(0.0), sigErr2TotSave(0.0),
866  sigErr2NDSave(0.0), weightSave(0.0), weightSumSave(0.0),
867  nCollSave(10, 0), nProjSave(10, 0), nTargSave(10, 0), nFailSave(0),
868  subColsPtr(NULL) {}
869 
870  // The impact-parameter distance in the current event.
871  double b() const {
872  return bSave;
873  }
874 
875  // The Monte Carlo integrated total cross section in the current run.
876  double sigmaTot() const {
877  return sigmaTotSave/millibarn;
878  }
879 
880  // The estimated statistical error on sigmaTot().
881  double sigmaTotErr() const {
882  return sqrt(sigErr2TotSave/max(1.0, double(NSave)))/millibarn;
883  }
884 
885  // The Monte Carlo integrated non-diffractive cross section in the
886  // current run.
887  double sigmaND() const {
888  return sigmaNDSave/millibarn;
889  }
890 
891  // The estimated statistical error on sigmaND().
892  double sigmaNDErr() const {
893  return sqrt(sigErr2NDSave/max(1.0, double(NSave)));
894  }
895 
896  // The number of attempted impact parameter points.
897  long nAttempts() const {
898  return NSave;
899  }
900 
901  // The number of produced events.
902  long nAccepted() const {
903  return NAccSave;
904  }
905 
906  // The total number of separate sub-collisions.
907  int nCollTot() const { return nCollSave[0]; }
908 
909  // The number of separate non-diffractive sub collisions in the
910  // current event.
911  int nCollND() const { return nCollSave[1]; }
912 
913  // The total number of non-diffractive sub collisions in the current event.
914  int nCollNDTot() const { return nProjSave[1] + nTargSave[1] - nCollSave[1]; }
915 
916  // The number of separate single diffractive projectile excitation
917  // sub collisions in the current event.
918  int nCollSDP() const { return nCollSave[2]; }
919 
920  // The number of separate single diffractive target excitation sub
921  // collisions in the current event.
922  int nCollSDT() const { return nCollSave[3]; }
923 
924  // The number of separate double diffractive sub collisions in the
925  // current event.
926  int nCollDD() const { return nCollSave[4]; }
927 
928  // The number of separate double diffractive sub collisions in the
929  // current event.
930  int nCollCD() const { return nCollSave[5]; }
931 
932  // The number of separate elastic sub collisions.
933  int nCollEL() const { return nCollSave[6]; }
934 
935  // The number of interacting projectile nucleons in the current
936  // event.
937  int nPartProj() const { return nProjSave[0]; }
938 
939  // The number of absorptively wounded projectile nucleons in the
940  // current event.
941  int nAbsProj() const { return nProjSave[1]; }
942 
943  // The number of diffractively wounded projectile nucleons in the
944  // current event.
945  int nDiffProj() const { return nProjSave[2]; }
946 
947  // The number of elastically scattered projectile nucleons in the
948  // current event.
949  int nElProj() const { return nProjSave[3]; }
950 
951  // The number of interacting projectile nucleons in the current
952  // event.
953  int nPartTarg() const { return nTargSave[0]; }
954 
955  // The number of absorptively wounded projectile nucleons in the
956  // current event.
957  int nAbsTarg() const { return nTargSave[1]; }
958 
959  // The number of diffractively wounded projectile nucleons in the
960  // current event.
961  int nDiffTarg() const { return nTargSave[2]; }
962 
963  // The number of elastically scattered projectile nucleons in the
964  // current event.
965  int nElTarg() const { return nTargSave[3]; }
966 
967  // The weight for this collision.
968  double weight() const { return weightSave; }
969 
970  // The sum of weights of the produced events.
971  double weightSum() const { return weightSumSave; }
972 
973  // The number of failed nuclon excitations in the current event.
974  int nFail() const {
975  return nFailSave;
976  }
977 
978  // Register a failed nucleon excitation.
980  ++nFailSave;
981  }
982 
983  // The number of separate non-diffractive collisions.
984 private:
985 
986  // Register a tried impact parameter point giving the total elastic
987  // amplitude, the impact parameter and impact parameter generation weight.
988  void addAttempt(double T, double bin, double bweight);
989 
990  // Reweight event for whatever reason.
991  void reweight(double w) {
992  weightSave *= w;
993  }
994 
995  // Select the primary process.
996  void select(Info & in) {
997  primInfo = in;
998  primInfo.hiInfo = this;
999  }
1000 
1001  // Accept an event and update statistics in info.
1002  void accept();
1003 
1004  // Reject an attmpted event.
1005  void reject() {}
1006 
1007  // Register a full sub collision.
1008  int addSubCollision(const SubCollision & c);
1009 
1010  // Register a participating projectile/target nucleon.
1011  int addProjectileNucleon(const Nucleon & n);
1012  int addTargetNucleon(const Nucleon & n);
1013 
1014 
1015  // Id of the colliding nuclei.
1016  int idProjSave, idTargSave;
1017 
1018  // Impact parameter.
1019  double bSave;
1020 
1021  // Cross section estimates.
1022  long NSave, NAccSave;
1023  double sigmaTotSave, sigmaNDSave, sigErr2TotSave, sigErr2NDSave;
1024  double weightSave, weightSumSave;
1025 
1026  // Number of collisions and paricipants. See accessor functions for
1027  // indices.
1028  vector<int> nCollSave, nProjSave, nTargSave;
1029 
1030  // Map of primary processes and the number of events and the sum of
1031  // weights.
1032  map<int,double> sumPrimW, sumPrimW2;
1033  map<int,int> NPrim;
1034  map<int,string> NamePrim;
1035 
1036  // The info object of the primary process.
1037  Info primInfo;
1038 
1039  // Number of failed nucleon excitations.
1040  int nFailSave;
1041 
1042 
1043 public:
1044  // Access to subcollision to be extracted by the user.
1045  multiset<SubCollision>* subCollisionsPtr() { return subColsPtr; }
1046 
1047  void subCollisionsPtr(multiset<SubCollision> * sPtrIn) {
1048  subColsPtr = sPtrIn; }
1049 
1050 private:
1051 
1052  // Full information about the Glauber calculation, consisting of
1053  // all subcollisions.
1054  multiset<SubCollision>* subColsPtr;
1055 
1056 };
1057 
1058 //==========================================================================
1059 
1060 // This is the heavy ion user hooks class which in the future may be
1061 // used inside a Pythia object to generate heavy ion collisons. For
1062 // now it is used outside Pythia and requires access to a number of
1063 // Pythia objects.
1064 
1066 
1067 public:
1068 
1069  // The default constructor is empty.
1070  HIUserHooks(): idProjSave(0), idTargSave(0) {}
1071 
1072  // Virtual destructor.
1073  virtual ~HIUserHooks() {}
1074 
1075  // Initialize this user hook.
1076  virtual void init(int idProjIn, int idTargIn) {
1077  idProjSave = idProjIn;
1078  idTargSave = idTargIn;
1079  }
1080 
1081  // A user-supplied impact parameter generator.
1082  virtual bool hasImpactParameterGenerator() const { return false; }
1083  virtual ImpactParameterGenerator * impactParameterGenerator() const {
1084  return 0; }
1085 
1086  // A suser-supplied NucleusModel for the projectile and target.
1087  virtual bool hasProjectileModel() const { return false; }
1088  virtual NucleusModel * projectileModel() const { return 0; }
1089  virtual bool hasTargetModel() const { return false; }
1090  virtual NucleusModel * targetModel() const { return 0; }
1091 
1092  // A user-supplied SubCollisionModel for generating nucleon-nucleon
1093  // subcollisions.
1094  virtual bool hasSubCollisionModel() { return false; }
1095  virtual SubCollisionModel * subCollisionModel() { return 0; }
1096 
1097  // A user-supplied ordering of events in (inverse) hardness.
1098  virtual bool hasEventOrdering() const { return false; }
1099  virtual double eventOrdering(const Event &, const Info &) { return -1; }
1100 
1101  // A user-supplied method for fixing up proton-neutron mismatch in
1102  // generated beams.
1103  virtual bool canFixIsoSpin() const { return false; }
1104  virtual bool fixIsoSpin(EventInfo &) { return false; }
1105 
1106  // A user-supplied method for shifting the event in impact parameter space.
1107  virtual bool canShiftEvent() const { return false; }
1108  virtual EventInfo & shiftEvent(EventInfo & ei) const { return ei; }
1109 
1110  // A user-supplied method of adding a diffractive excitation event
1111  // to another event, optionally connecting their colours.
1112  bool canAddNucleonExcitation() const { return false; }
1113  bool addNucleonExcitation(EventInfo &, EventInfo &, bool) const {
1114  return false; }
1115 
1116  // A user supplied wrapper around the Pythia::forceHadronLevel()
1117  virtual bool canForceHadronLevel() const { return false; }
1118  virtual bool forceHadronLevel(Pythia &) { return false; }
1119 
1120  // A user-supplied way of finding the remnants of an
1121  // non-diffrcative pp collision (on the target side if tside is
1122  // true) to be used to give momentum when adding.
1123  virtual bool canFindRecoilers() const { return false; }
1124  virtual vector<int>
1125  findRecoilers(const Event &, bool /* tside */, int /* beam */, int /* end */,
1126  const Vec4 & /* pdiff */, const Vec4 & /* pbeam */) const {
1127  return vector<int>();
1128  }
1129 
1130 protected:
1131 
1132  // Information set in the init() function.
1133  // The PDG id of the projectile and target nuclei.
1134  int idProjSave, idTargSave;
1135 
1136 };
1137 
1138 //==========================================================================
1139 
1140 } // end namespace Pythia8
1141 
1142 #endif // Pythia8_HIUserHooks_H
void select(EventInfo &evp, Status s)
Select an event for this nucleon.
Definition: HIUserHooks.h:132
int nCollSDP() const
Definition: HIUserHooks.h:918
virtual bool init()
Initialise in a subclass. Only a dummy in this base class.
Definition: HIUserHooks.cc:51
Z0 Z(f is quark or lepton).*/ void Sigma1ffbar2gmZZprime
Initialize process.
Definition: SigmaNewGaugeBosons.cc:110
constexpr double pow2(const double &x)
Powers of small integers - for balance speed/code clarity.
Definition: PythiaStdlib.h:153
virtual void init(int idProjIn, int idTargIn)
Initialize this user hook.
Definition: HIUserHooks.h:1076
bool canAddNucleonExcitation() const
Definition: HIUserHooks.h:1112
virtual bool canFindRecoilers() const
Definition: HIUserHooks.h:1123
long nAttempts() const
The number of attempted impact parameter points.
Definition: HIUserHooks.h:897
double weight() const
The weight for this collision.
Definition: HIUserHooks.h:968
int nElProj() const
Definition: HIUserHooks.h:949
int nFail() const
The number of failed nuclon excitations in the current event.
Definition: HIUserHooks.h:974
virtual bool canShiftEvent() const
A user-supplied method for shifting the event in impact parameter space.
Definition: HIUserHooks.h:1107
Status status() const
The status.
Definition: HIUserHooks.h:103
int nCollND() const
Definition: HIUserHooks.h:911
int nCollEL() const
The number of separate elastic sub collisions.
Definition: HIUserHooks.h:933
GLISSANDOModel()
Default constructor.
Definition: HIUserHooks.h:356
double a() const
Accessor functions:
Definition: HIUserHooks.h:309
Definition: Info.h:42
bool done() const
Check if nucleon has been assigned.
Definition: HIUserHooks.h:106
The Event class holds all info on the generated event.
Definition: Event.h:379
double sigSDE() const
The single diffractive excitation cross section (both sides summed).
Definition: HIUserHooks.h:524
A general Woods-Saxon distributed nucleus.
Definition: HIUserHooks.h:299
SigEst()
Constructor for zeros.
Definition: HIUserHooks.h:468
Nucleon * targ
The target nucleon.
Definition: HIUserHooks.h:226
const Vec4 & bShift(const Vec4 &bvec)
Shift the absolute position in impact parameter space.
Definition: HIUserHooks.h:100
vector< double > phi
The angles defining the probability distribution for the radii.
Definition: HIUserHooks.h:807
double sigmaTotErr() const
The estimated statistical error on sigmaTot().
Definition: HIUserHooks.h:881
virtual void setParm(const vector< double > &)
Set the parameters of this model.
Definition: HIUserHooks.h:558
Definition: HIUserHooks.h:633
double avNDb
Definition: HIUserHooks.h:588
double RSave
The estimate of the nucleus radius.
Definition: HIUserHooks.h:286
double bSlope() const
The elastic b-slope parameter.
Definition: HIUserHooks.h:539
Info info
The corresponding Info object.
Definition: HIUserHooks.h:827
Definition: SigmaTotal.h:138
void width(double widthIn)
Set the width (in femtometers).
Definition: HIUserHooks.h:420
int NInt
Definition: HIUserHooks.h:582
double bp
Definition: HIUserHooks.h:233
virtual ~NaiveSubCollisionModel()
Virtual destructor,.
Definition: HIUserHooks.h:642
vector< double > State
The state of a nucleon is a general vector of doubles.
Definition: HIUserHooks.h:77
double alpha
Power of the saturation scale.
Definition: HIUserHooks.h:732
virtual ~MultiRadial()
Virtual destructor,.
Definition: HIUserHooks.h:757
const double femtometer2
Cross sections.
Definition: HIUserHooks.h:47
double sigND() const
The non-diffractive (absorptive) cross section.
Definition: HIUserHooks.h:536
BlackSubCollisionModel()
Definition: HIUserHooks.h:613
Both excited but with central diffraction.
Definition: HIUserHooks.h:201
double avNDb
Definition: HIUserHooks.h:465
double b() const
The impact-parameter distance in the current event.
Definition: HIUserHooks.h:871
double sigCDE() const
The central diffractive excitation cross section.
Definition: HIUserHooks.h:521
virtual ~BlackSubCollisionModel()
Virtual destructor,.
Definition: HIUserHooks.h:616
vector< double > T0
The opacity for different radii.
Definition: HIUserHooks.h:804
const Vec4 & bPos() const
The absolute position in impact parameter space.
Definition: HIUserHooks.h:97
Definition: HIUserHooks.h:62
double sigmaTot() const
The Monte Carlo integrated total cross section in the current run.
Definition: HIUserHooks.h:876
int nCollCD() const
Definition: HIUserHooks.h:930
Definition: HIUserHooks.h:245
multiset< SubCollision > * subCollisionsPtr()
Access to subcollision to be extracted by the user.
Definition: HIUserHooks.h:1045
const Vec4 & nPos() const
The position of this nucleon relative to the nucleus center.
Definition: HIUserHooks.h:94
Definition: HIUserHooks.h:394
int nElTarg() const
Definition: HIUserHooks.h:965
int index() const
The nucleon type.
Definition: HIUserHooks.h:91
int nPartTarg() const
Definition: HIUserHooks.h:953
virtual ~DoubleStrikman()
Virtual destructor,.
Definition: HIUserHooks.h:668
virtual bool init()
Definition: HIUserHooks.h:322
double sigd
Saturation scale of the nucleus.
Definition: HIUserHooks.h:729
const State & altState(int i=0)
Return an alternative state.
Definition: HIUserHooks.h:115
double r0
The average radius of the nucleon.
Definition: HIUserHooks.h:723
EventInfo * event() const
The event this nucleon is assigned to.
Definition: HIUserHooks.h:109
double avNDB() const
Return the average non-diffractive impact parameter.
Definition: HIUserHooks.h:547
virtual ~HIUserHooks()
Virtual destructor.
Definition: HIUserHooks.h:1073
Definition: HIUserHooks.h:351
Both projectile and target are diffractively excited.
Definition: HIUserHooks.h:200
NucleusModel * projPtr
Info from the controlling HeavyIons object.
Definition: HIUserHooks.h:591
Definition: HIUserHooks.h:1065
Definition: HIUserHooks.h:745
double ordering
The ordering variable of this event.
Definition: HIUserHooks.h:833
vector< bool > fsig
Which cross sections were actually fitted.
Definition: HIUserHooks.h:461
double weightSum() const
The sum of weights of the produced events.
Definition: HIUserHooks.h:971
virtual bool hasSubCollisionModel()
Definition: HIUserHooks.h:1094
virtual vector< double > getParm() const
Definition: HIUserHooks.h:562
Event event
The Event object.
Definition: HIUserHooks.h:824
virtual bool hasImpactParameterGenerator() const
A user-supplied impact parameter generator.
Definition: HIUserHooks.h:1082
Definition: Basics.h:349
void failedExcitation()
Register a failed nucleon excitation.
Definition: HIUserHooks.h:979
double width() const
Get the width.
Definition: HIUserHooks.h:423
MultiRadial(int NrIn=0)
Definition: HIUserHooks.h:751
Type type
The type of collison.
Definition: HIUserHooks.h:236
vector< double > dR
The difference between radii.
Definition: HIUserHooks.h:801
map< Nucleon *, pair< int, int > > projs
Definition: HIUserHooks.h:846
double sigmaND() const
Definition: HIUserHooks.h:887
vector< double > c
The probability distribution.
Definition: HIUserHooks.h:798
vector< double > dsig2
The extimated error (squared)
Definition: HIUserHooks.h:458
bool ok
Is the event properly generated?
Definition: HIUserHooks.h:842
int nPartProj() const
Definition: HIUserHooks.h:937
HIInfo * hiInfo
Definition: Info.h:120
SubCollisionModel()
The default constructor is empty.
Definition: HIUserHooks.h:476
Definition: HIUserHooks.h:607
virtual ~ImpactParameterGenerator()
Virtual destructor.
Definition: HIUserHooks.h:405
Status
Enum for specifying the status of a nucleon.
Definition: HIUserHooks.h:69
Definition: HIUserHooks.h:448
double sigmaNDErr() const
The estimated statistical error on sigmaND().
Definition: HIUserHooks.h:892
const int debug
Debug verbosity levels.
Definition: VinciaCommon.h:85
double aSave
Definition: HIUserHooks.h:334
double sigDDE() const
The double diffractive excitation cross section.
Definition: HIUserHooks.h:533
int code
The code for the subprocess.
Definition: HIUserHooks.h:830
DoubleStrikman(int modein=0)
Definition: HIUserHooks.h:664
SubCollisionModel * collPtr
Info from the controlling HeavyIons object.
Definition: HIUserHooks.h:433
int nCollDD() const
Definition: HIUserHooks.h:926
Definition: HIUserHooks.h:190
Internal class to report cross section estimates.
Definition: HIUserHooks.h:453
int idSave
The nucleus.
Definition: HIUserHooks.h:280
int id() const
Accessor functions:
Definition: HIUserHooks.h:88
Definition: Event.h:32
virtual bool hasProjectileModel() const
A suser-supplied NucleusModel for the projectile and target.
Definition: HIUserHooks.h:1087
int opacityMode
Optional mode for opacity.
Definition: HIUserHooks.h:735
void status(Status s)
Manipulating functions:
Definition: HIUserHooks.h:123
int ISave
Cache information about the nucleus.
Definition: HIUserHooks.h:283
void state(State s)
Set the physical state.
Definition: HIUserHooks.h:126
void select()
Select this nucleon to be assigned to an event.
Definition: HIUserHooks.h:139
HIUserHooks()
The default constructor is empty.
Definition: HIUserHooks.h:1070
Class for storing Events and Info objects.
Definition: HIUserHooks.h:816
double Tpt(const Nucleon::State &p, const Nucleon::State &t, double b) const
Definition: HIUserHooks.h:768
int idProjSave
Definition: HIUserHooks.h:1134
double Rh() const
Accessor functions.
Definition: HIUserHooks.h:369
int nAbsTarg() const
Definition: HIUserHooks.h:957
int nucleons() const
Definition: HIUserHooks.h:217
int id() const
Accessor functions.
Definition: HIUserHooks.h:270
Definition: HIUserHooks.h:658
virtual ~NucleusModel()
Virtual destructor.
Definition: HIUserHooks.h:256
int nAbsProj() const
Definition: HIUserHooks.h:941
HIInfo()
Constructor.
Definition: HIUserHooks.h:863
virtual ~SubCollisionModel()
Virtual destructor,.
Definition: HIUserHooks.h:481
int Nr
The number of radii.
Definition: HIUserHooks.h:794
void addAltState(State s)
Add an alternative state.
Definition: HIUserHooks.h:129
double sigEl() const
The total cross section.
Definition: HIUserHooks.h:518
WoodsSaxonModel()
Definition: HIUserHooks.h:305
double phi(const Vec4 &v1, const Vec4 &v2)
phi is azimuthal angle between v1 and v2 around z axis.
Definition: Basics.cc:539
int nCollNDTot() const
The total number of non-diffractive sub collisions in the current event.
Definition: HIUserHooks.h:914
double Tpt(const Nucleon::State &p, const Nucleon::State &t, double b) const
Definition: HIUserHooks.h:691
NucleusModel()
Definition: HIUserHooks.h:251
virtual bool canFixIsoSpin() const
Definition: HIUserHooks.h:1103
This is not a collision.
Definition: HIUserHooks.h:196
The projectile is diffractively excited.
Definition: HIUserHooks.h:198
Header for classes to set beam momentum and interaction vertex spread.
Definition: Analysis.h:20
The Pythia class contains the top-level routines to generate an event.
Definition: Pythia.h:65
int nCollSDT() const
Definition: HIUserHooks.h:922
const State & state() const
The physical state of the incoming nucleon.
Definition: HIUserHooks.h:112
double sigSDET() const
The single diffractive excitation cross section (excited target).
Definition: HIUserHooks.h:530
double k0
The power in the Gamma distribution.
Definition: HIUserHooks.h:726
int nDiffTarg() const
Definition: HIUserHooks.h:961
Type
This defines the type of a bunary nucleon collison.
Definition: HIUserHooks.h:195
Nucleon(int idIn=0, int indexIn=0, const Vec4 &pos=Vec4())
Definition: HIUserHooks.h:81
double sigTot() const
The total cross section.
Definition: HIUserHooks.h:513
Settings * settingsPtr
Pointers to useful objects.
Definition: HIUserHooks.h:289
const SubCollision * coll
The associated SubCollision object.
Definition: HIUserHooks.h:839
const double femtometer
Lengths.
Definition: HIUserHooks.h:43
double sigSDEP() const
The single diffractive excitation cross section (excited projectile).
Definition: HIUserHooks.h:527
This is an elastic scattering.
Definition: HIUserHooks.h:197
Nucleon * proj
The projectile nucleon.
Definition: HIUserHooks.h:223
virtual bool canForceHadronLevel() const
A user supplied wrapper around the Pythia::forceHadronLevel()
Definition: HIUserHooks.h:1117
virtual bool hasEventOrdering() const
A user-supplied ordering of events in (inverse) hardness.
Definition: HIUserHooks.h:1098
int nDiffProj() const
Definition: HIUserHooks.h:945
vector< double > sig
The cross sections (tot, nd, dd, sdp, sdt, cd, el, bslope).
Definition: HIUserHooks.h:455
Definition: HeavyIons.h:31
virtual SigEst getSig() const
Calculate the cross sections for the given set of parameters.
Definition: HIUserHooks.h:542
This class holds a map of all ParticleDataEntries.
Definition: ParticleData.h:420
virtual ~GLISSANDOModel()
Virtual destructor.
Definition: HIUserHooks.h:359
Definition: Basics.h:31
EventInfo()
Empty constructor.
Definition: HIUserHooks.h:821
The default HeavyIon model in Pythia.
Definition: HeavyIons.h:148
virtual ~WoodsSaxonModel()
Virtual destructor.
Definition: HIUserHooks.h:318
double opacity(double sig) const
The opacity of the collision at a given sigma.
Definition: HIUserHooks.h:681
Definition: HIUserHooks.h:855
ImpactParameterGenerator()
Definition: HIUserHooks.h:400
long nAccepted() const
The number of produced events.
Definition: HIUserHooks.h:902
Definition: Settings.h:195
double b
The impact parameter distance between the nucleons in femtometer.
Definition: HIUserHooks.h:229
int nCollTot() const
The total number of separate sub-collisions.
Definition: HIUserHooks.h:907
NaiveSubCollisionModel()
Definition: HIUserHooks.h:639
The target is diffractively excited.
Definition: HIUserHooks.h:199