示例#1
0
def three_particle_free_non_equilibrium_test(params):
    eps = 1e-14

    photon = Particle(**SMP.photon)
    neutrino_e = Particle(**SMP.leptons.neutrino_e)
    neutrino_mu = Particle(**SMP.leptons.neutrino_mu)
    sterile = Particle(**NuP.dirac_sterile_neutrino(mass=140 * UNITS.MeV))
    neutral_pion = Particle(**SMP.hadrons.neutral_pion)

    theta = 1e-3
    thetas = defaultdict(float, {
        'electron': theta,
    })

    interaction = NuI.sterile_hadrons_interactions(
        thetas = thetas, sterile=sterile,
        neutrinos = [neutrino_e],
        leptons = [],
        mesons = [neutral_pion]
    )

    universe = Universe(params=params)
    universe.add_particles([photon, neutrino_e, neutrino_mu, sterile, neutral_pion])
    universe.interactions += interaction

    params.update(universe.total_energy_density(), universe.total_entropy())

    universe.update_particles()
    universe.init_interactions()

    photon_distribution = photon._distribution
    neutrino_e_distribution = neutrino_e._distribution
    neutrino_mu_distribution = neutrino_mu._distribution
    sterile_distribution = sterile._distribution
    neutral_pion_distribution = neutral_pion._distribution

    universe.calculate_collisions()

    assert all(photon.collision_integral == 0), "Equilibrium particle integral is non-zero"
    assert all(numpy.abs(neutrino_e.collision_integral * params.h) < eps), "Integrals do not cancel"
    assert all(numpy.abs(sterile.collision_integral * params.h) < eps), "Integrals do not cancel"
    assert all(numpy.abs(neutral_pion.collision_integral * params.h) < eps), "Integrals do not cancel"
    assert all(neutrino_mu.collision_integral == 0), "Free particle integral is non-zero"

    universe.update_distributions()

    assert all(photon._distribution == photon_distribution),\
        "Equilibrium particle distribution changed"
    assert all(neutrino_e._distribution - neutrino_e_distribution < eps),\
        "Interacting particle distribution changed"
    assert all(sterile._distribution - sterile_distribution < eps),\
        "Interacting particle distribution changed"
    assert all(neutral_pion._distribution - neutral_pion_distribution < eps),\
        "Interacting particle distribution changed"
    assert all(neutrino_mu._distribution == neutrino_mu_distribution),\
        "Free particle distribution changed"
示例#2
0
def four_particle_decay_test(params):
    os.environ['SPLIT_COLLISION_INTEGRAL'] = ''

    photon = Particle(**SMP.photon)
    neutrino_e = Particle(**SMP.leptons.neutrino_e)
    sterile = Particle(**NuP.dirac_sterile_neutrino(mass=200 * UNITS.MeV))

    theta = 1e-4
    thetas = defaultdict(float, {
        'electron': theta,
    })

    interaction = NuI.sterile_leptons_interactions(
        thetas=thetas, sterile=sterile,
        neutrinos=[neutrino_e],
        leptons=[],
        kind = CollisionIntegralKind.F_f_vacuum_decay
    )

    for inter in interaction:
        inter.integrals = [integral for integral in inter.integrals
                            if sum(reactant.side for reactant in integral.reaction) in [2]]

    universe = Universe(params=params)
    universe.add_particles([photon, neutrino_e, sterile])
    universe.interactions += interaction

    params.update(universe.total_energy_density(), universe.total_entropy())

    universe.update_particles()
    universe.init_interactions()

    collision_integral = sterile.collision_integrals[0].integrate(sterile.grid.TEMPLATE)

    theo_value = (CONST.G_F * theta)**2 * sterile.mass**5 / (192 * numpy.pi**3) / UNITS.MeV

    decay_rate = -(collision_integral * sterile.params.H \
                * sterile.conformal_energy(sterile.grid.TEMPLATE) / sterile.conformal_mass \
                / sterile._distribution) / UNITS.MeV

    ratio = decay_rate / theo_value

    assert any(numpy.abs(val) - 1 < 1e-2 for val in ratio), "Four-particle decay test failed"
示例#3
0
def three_particle_decay_test(params):
    os.environ['SPLIT_COLLISION_INTEGRAL'] = ''

    photon = Particle(**SMP.photon)
    neutrino_e = Particle(**SMP.leptons.neutrino_e)
    sterile = Particle(**NuP.dirac_sterile_neutrino(mass=200 * UNITS.MeV))
    neutral_pion = Particle(**SMP.hadrons.neutral_pion)

    theta = 1e-2
    thetas = defaultdict(float, {
        'electron': theta,
    })

    interaction = NuI.sterile_hadrons_interactions(
        thetas = thetas, sterile=sterile,
        neutrinos = [neutrino_e],
        leptons = [],
        mesons = [neutral_pion],
        kind = CollisionIntegralKind.F_f_vacuum_decay
    )

    universe = Universe(params=params)
    universe.add_particles([photon, neutrino_e, sterile, neutral_pion])
    universe.interactions += interaction

    params.update(universe.total_energy_density(), universe.total_entropy())

    universe.update_particles()
    universe.init_interactions()

    collision_integral = sterile.collision_integrals[0].integrate(sterile.grid.TEMPLATE)

    theo_value = (CONST.G_F * theta * neutral_pion.decay_constant)**2 \
                * sterile.mass**3 * (1 - (neutral_pion.mass / sterile.mass)**2)**2 \
                / (16 * numpy.pi) / UNITS.MeV

    decay_rate = -(collision_integral * sterile.params.H \
                * sterile.conformal_energy(sterile.grid.TEMPLATE) / sterile.conformal_mass \
                / sterile._distribution) / UNITS.MeV

    ratio = decay_rate / theo_value

    assert any(numpy.abs(val) - 1 < 1e-2 for val in ratio), "Three-particle decay test failed"
示例#4
0
def three_particle_integral_light_test(params):
    """ If M_N < M_pi, there should be integrals for the reactions:

        N + anti-nu_e <--> pion
        nu_e + anti-N <--> pion
        pi^0 <--> anti-nu_e + N
        pi^0 <--> nu_e + anti-N
    """

    photon = Particle(**SMP.photon)
    neutrino_e = Particle(**SMP.leptons.neutrino_e)
    sterile = Particle(**NuP.dirac_sterile_neutrino(mass=100 * UNITS.MeV))
    neutral_pion = Particle(**SMP.hadrons.neutral_pion)

    theta = 1e-3
    thetas = defaultdict(float, {
        'electron': theta,
    })

    interaction = NuI.sterile_hadrons_interactions(
        thetas=thetas, sterile=sterile,
        neutrinos=[neutrino_e],
        leptons=[],
        mesons=[neutral_pion]
    )

    universe = Universe(params=params)
    universe.add_particles([photon, neutrino_e, sterile, neutral_pion])
    universe.interactions += interaction

    assert len(universe.interactions) == 2
    assert len(universe.interactions[0].integrals) == 2
    assert len(universe.interactions[1].integrals) == 2

    integral = universe.interactions[0].integrals[0]
    assert len(integral.Ms) == 1
    assert isinstance(integral.Ms[0].K, (int, float))
def three_particle_integral_test(params):

    photon = Particle(**SMP.photon)
    neutrino_e = Particle(**SMP.leptons.neutrino_e)
    sterile = Particle(**NuP.dirac_sterile_neutrino(mass=200 * UNITS.MeV))
    neutral_pion = Particle(**SMP.hadrons.neutral_pion)

    pion_interactions = NuI.sterile_pion_neutral(theta=1e-3, sterile=sterile,
                                                 active=neutrino_e, pion=neutral_pion)

    universe = Universe(params=params, plotting=False)
    universe.add_particles([photon, neutrino_e, sterile, neutral_pion])
    universe.interactions += pion_interactions

    params.update(universe.total_energy_density())

    print universe.interactions
    assert len(universe.interactions) == 2
    print universe.interactions[0].integrals
    print universe.interactions[1].integrals
    assert len(universe.interactions[0].integrals) == 2
    assert len(universe.interactions[1].integrals) == 3
    integral = universe.interactions[0].integrals[0]
    assert len(integral.Ms) == 1
示例#6
0
universe = Universe(params=params, folder=folder)

photon = Particle(**SMP.photon)

electron = Particle(**SMP.leptons.electron)
muon = Particle(**SMP.leptons.muon)
tau = Particle(**SMP.leptons.tau)

neutrino_e = Particle(**SMP.leptons.neutrino_e)
neutrino_mu = Particle(**SMP.leptons.neutrino_mu)
neutrino_tau = Particle(**SMP.leptons.neutrino_tau)

neutral_pion = Particle(**SMP.hadrons.neutral_pion)
charged_pion = Particle(**SMP.hadrons.charged_pion)

sterile = Particle(**NuP.dirac_sterile_neutrino(mass))
sterile_grid = LogSpacedGrid(10, T_initial * 5)
sterile.set_grid(sterile_grid)
sterile.decoupling_temperature = T_initial

grid = HeuristicGrid(mass, lifetime)
for neutrino in [neutrino_e, neutrino_mu, neutrino_tau]:
    neutrino.decoupling_temperature = 0 * UNITS.MeV
    neutrino.set_grid(grid)


universe.add_particles([
    photon,

    electron,
    muon,
示例#7
0
    args.comment)

T_initial = Tdec
T_interactions_freeze_out = 0.005 * UNITS.MeV
T_final = 0.0008 * UNITS.MeV
params = Params(T=T_initial, dy=0.003125)

universe = Universe(params=params, folder=folder)

photon = Particle(**SMP.photon)
electron = Particle(**SMP.leptons.electron)
muon = Particle(**SMP.leptons.muon)
neutrino_e = Particle(**SMP.leptons.neutrino_e)
neutrino_mu = Particle(**SMP.leptons.neutrino_mu)
neutrino_tau = Particle(**SMP.leptons.neutrino_tau)
sterile = Particle(**NuP.dirac_sterile_neutrino(mass))

from common import LogSpacedGrid
linear_grid = LogSpacedGrid()

sterile.decoupling_temperature = T_initial
for neutrino in [neutrino_e, neutrino_mu, neutrino_tau]:
    neutrino.decoupling_temperature = 10 * UNITS.MeV

universe.add_particles([
    photon,
    electron,
    muon,
    neutrino_e,
    neutrino_mu,
    neutrino_tau,
示例#8
0
文件: __main__.py 项目: ckald/pyBBN
from common import LinearSpacedGrid
linear_grid = LinearSpacedGrid(MOMENTUM_SAMPLES=501, MAX_MOMENTUM=500*UNITS.MeV)
linear_grid_s = LinearSpacedGrid(MOMENTUM_SAMPLES=51, MAX_MOMENTUM=10*UNITS.MeV)

photon = Particle(**SMP.photon)

electron = Particle(**SMP.leptons.electron, grid=linear_grid)

neutrino_e = Particle(**SMP.leptons.neutrino_e, grid=linear_grid)
neutrino_mu = Particle(**SMP.leptons.neutrino_mu, grid=linear_grid)
neutrino_tau = Particle(**SMP.leptons.neutrino_tau, grid=linear_grid)

for neutrino in [neutrino_e, neutrino_mu, neutrino_tau]:
    neutrino.decoupling_temperature = 0 * UNITS.MeV

sterile = Particle(**NuP.dirac_sterile_neutrino(mass), grid=linear_grid_s)
sterile.decoupling_temperature = T_initial

universe.add_particles([
    photon,

    electron,

    neutrino_e,
    neutrino_mu,
    neutrino_tau,

    sterile,
])

thetas = defaultdict(float, {
示例#9
0
                               MAX_MOMENTUM=500 * UNITS.MeV)
linear_grid_s = LinearSpacedGrid(MOMENTUM_SAMPLES=51,
                                 MAX_MOMENTUM=10 * UNITS.MeV)

photon = Particle(**SMP.photon)

electron = Particle(**SMP.leptons.electron, grid=linear_grid)

neutrino_e = Particle(**SMP.leptons.neutrino_e, grid=linear_grid)
neutrino_mu = Particle(**SMP.leptons.neutrino_mu, grid=linear_grid)
neutrino_tau = Particle(**SMP.leptons.neutrino_tau, grid=linear_grid)

for neutrino in [neutrino_e, neutrino_mu, neutrino_tau]:
    neutrino.decoupling_temperature = 0 * UNITS.MeV

sterile = Particle(**NuP.dirac_sterile_neutrino(mass), grid=linear_grid_s)
sterile.decoupling_temperature = T_initial

universe.add_particles([
    photon,
    electron,
    neutrino_e,
    neutrino_mu,
    neutrino_tau,
    sterile,
])

thetas = defaultdict(float, {
    'tau': theta,
})
示例#10
0
                dy=0.003125 * 4)

universe = Universe(params=params, folder=folder)

photon = Particle(**SMP.photon)
electron = Particle(**SMP.leptons.electron)
muon = Particle(**SMP.leptons.muon)

from common import LogSpacedGrid
active_grid = LogSpacedGrid(MOMENTUM_SAMPLES=201, MAX_MOMENTUM=1.5 * mass / (T_washout / UNITS.MeV))
sterile_grid = LogSpacedGrid(MOMENTUM_SAMPLES=51, MAX_MOMENTUM=mass)

neutrino_e = Particle(**SMP.leptons.neutrino_e, grid=active_grid)
neutrino_mu = Particle(**SMP.leptons.neutrino_mu, grid=active_grid)
neutrino_tau = Particle(**SMP.leptons.neutrino_tau, grid=active_grid)
sterile = Particle(**NuP.dirac_sterile_neutrino(mass), grid=sterile_grid)

sterile.decoupling_temperature = T_initial

universe.add_particles([
    photon,
    electron,
    muon,
    neutrino_e,
    neutrino_mu,
    neutrino_tau,
    sterile,
])

thetas = defaultdict(float, {
    'tau': theta,