PhaseSpace ClassΒΆ
This class implements the phase-space Monte Carlo event generation where N is the number
of particles in the final state. Currently PhaseSpace class supports up-to
N=10 number of particles in the Final state. Most of the PhaseSpace class
methods can work on both HOST
and DEVICE
. The number of particles is
associated with suffix with the class name.
This class is the wrapper for the C++ PhaseSpace class. The PhaseSpace class contains one constructor to instantiate it:
- Constructor with N number of daughter masses.
import HydraPython as hypy
p = hypy.PhaseSpace4([3.096916, 0.493677, 0.13957018, 0.0195018])
# This will construct the PhaseSpace object with the 4 daughter masses in the list.
The PhaseSpace classes provides a method to generate a phase-space decay given an output range or a phase-space given a range of mother particles and an output range.
# The below example generates and fills 3 states of 4 particle host events
vec4 = hypy.Vector4R(5.2795, 0.0, 0.0, 0.0)
ps = hypy.PhaseSpace4([3.096916, 0.493677, 0.13957018, 0.0195018])
e_host = hypy.host_events_4(3)
e_device = hypy.device_events_4(3)
ps.GenerateOnhost(vec4, e_host) # Generate particle on host
ps.GenerateOndevice(vec4, e_device) # Generate particle on device
B0_mass = 5.27955
B0 = hypy.Vector4R(B0_mass, 0.0, 0.0, 0.0)
mothers = hypy.host_vector_float4(5)
# Fill mother with some particles
mothers[0] = (3.326536152819228, -0.7376241292510032, 0.9527533342879685, 0.15239715864543849)
mothers[1] = (3.3327060111834546, -0.44741166640978447, 1.012640505284964, -0.5390007001803998)
mothers[2] = (3.4673036097962844, 0.6781637974979919, -1.4020213115136253, -0.0763859825560801)
mothers[3] = (3.5042443315560945, 1.5383404921780213, -0.1442073504412384, -0.5492280905481964)
mothers[4] = (3.4406218104833015, -0.16339927010014546, 1.363729549941791, 0.6005257912194031)
phsp2 = hypy.PhaseSpace2([0.1056583745, 0.1056583745])
grand_daughter = hypy.host_events_2(5)
phsp2.GenerateOnhost(mothers, grand_daughter)
for i in grand_daughter: print(i)
The AverageOnhost
and AverageOndevice
method by PhaseSpace classes calculate the
mean
and sqrt(variance)
of a functor over the phase-space with n-samples or
of a functor over the phase-space given a list of mother particles.
import HydraPython as hypy
import math
def foo(*data):
p1, p2, p3 = data[0], data[1], data[2]
p = p1 + p2 + p3
q = p2 + p3
pd = p * p2
pq = p * q
qd = q * p2
mp2 = p.mass2()
mq2 = q.mass2()
md2 = p2.mass2()
return (pd * mq2 - pq * qd) / math.sqrt((pq * pq - mq2 * mp2) * (qd * qd - mq2 * md2))
vec4 = hypy.Vector4R(5.2795, 0.0, 0.0, 0.0)
p = hypy.PhaseSpace4([3.096916, 0.493677, 0.13957018, 0.0195018])
tup = p.AverageOnhost(vec4, foo, 10) # Average of host, currently passing functor to device will fail
print (tup[0]) # Mean
print (tup[1]) # sqrt of variance
Like generators, the AverageOn method also can accept the list of mother particle instead of one mother particle
and calculate the mean
and sqrt(variance)
.
The EvaluateOnhost
and EvaluateOndevice
evaluates a functor over the passed one mother particle or the list
of mother particles.
The complete list of class implementations can be found at [1] and the complete list of methods supported can be found at [2].
[1] | The list of PhaseSpace classe implementations
|
[2] | The list of methods for the PhaseSpace classes
|