void VinClu(int iMap, vector< Particle> pIn, int a, int r, int
b, vector< Particle>& pClu);
iMap
is the
index number of the kinematics map to be used (the numbering follows
VinciaShower:kineMapType
), pIn
is a vector of
arbitrary size containing the state of particles to be clustered,
and the indices a
, r
, b
represent the 3 particles to be clustered in the backwards
reconstruction of AB->arb. pClu
is initially
set equal to p
. The reconstructed momenta of the parents, A
and B, are then stored in pClu[a]
and pClu[b]
, respectively, and
finally pClu[r]
is erased. (Note that this last step
may cause the indices of A and/or B
in pClu
to be different from
those of a and b in p
. For the most
common case, a
color-ordered clustering with r=a+1 and b=a+2,
the indices of A and B after the clustering will
be A=a and B=A+1.)
The Rambo algorithm for flat phase-space generation is a standalone utility which is not used by VINCIA internally (VINCIA uses the antenna shower as its phase space generator instead). We (the authors) use the Rambo implementation mostly to make (un)weighted phase-space scans for comparisons between matrix elements and antenna shower expansions, but it is obviously a tool with a great variety of possible uses. If you use it, please add a reference to
When the VINCIA plugin is constructed, a member object
called rambo
is automatically constructed and initialized
inside the plugin. As mentioned, this object is not actually used by
VINCIA, but is available to the user if
needed.
A uniformly distributed (flat) n-particle phase-space point can then be generated by using the member function
rambo.genPoint(double S,int nPartons,double p[4][8]);
|
S
is the desired center-of-mass energy
squared, nPartons <= 8
sets the multiplicity,
and the momenta are returned in the double array p
, whose
entries can be converted to PYTHIA 8's Vec4
format in the
following way:
Vec4 VecP;
VecP.px(p[1][iParton]);
VecP.py(p[2][iParton]);
VecP.pz(p[3][iParton]);
VecP.e(p[0][iParton]);
|
0 <= iParton <= nPartons-1
.
If desired, further Rambo
generators could in
principle be created using the following Rambo
constructor
Vincia::Rambo myRambo(myRndmPtr);
|
myRndmPtr
should be a pointer to an instance of PYTHIA's
Rndm
class. For most purposes, however,
the automatically initialized rambo
object already provided
inside the VINCIA plugin should be sufficient.
string num2str(x, int width)
converts a
number, x
(int
or double
) to a
string of width width
for formatted output.
string bool2str(bool b)
converts a
bool to a string ("y"/"n") for formatted output.
void printOut(int verbLevel, string place, string
message);
if the current verbose
setting is
greater than or equal to verbLevel
, this command
prints the string message
to stdout
,
prefaced by place
in parenthesis.
void printErr(int verbLevel, string place, string
message);
same as above but prints to stderr
instead of stdout
.
namespace
Vincia
as:
int factorial(int n)
int binomial(int n, int m)
namespace
Vincia
as:
double Li2(double x, double kmax, double xerr)
namespace
Vincia
:
double lnGamma(double x)
double Gamma(double x)
double integrateGauss(double (*fun)(double), double xlo, double xhi,
double tol);
double zbrent(double (*fun)(double), double r, double x1, double
x2, double tol);
void makeSpline(vector< double>& x, vector< double>& y,
vector< double>& y2);
double getSpline(const double x, vector< double>& xa,
vector< double>& ya, vector< double>&
y2a);