Fatras/Physics/PhotonConversionTests.cpp

0001 // This file is part of the ACTS project.
0002 //
0003 // Copyright (C) 2016 CERN for the benefit of the ACTS project
0004 //
0005 // This Source Code Form is subject to the terms of the Mozilla Public
0006 // License, v. 2.0. If a copy of the MPL was not distributed with this
0007 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
0008
0009 #include <boost/test/data/test_case.hpp>
0010 #include <boost/test/unit_test.hpp>
0011
0012 #include "Acts/Definitions/Algebra.hpp"
0013 #include "Acts/Definitions/Common.hpp"
0014 #include "Acts/Definitions/PdgParticle.hpp"
0015 #include "Acts/Definitions/Units.hpp"
0016 #include "ActsFatras/EventData/Particle.hpp"
0017 #include "ActsFatras/Physics/ElectroMagnetic/PhotonConversion.hpp"
0018 #include "ActsTests/CommonHelpers/FloatComparisons.hpp"
0019
0020 #include <cmath>
0021 #include <limits>
0022 #include <memory>
0023 #include <random>
0024 #include <utility>
0025 #include <vector>
0026
0027 #include "Dataset.hpp"
0028
0029 using Generator = std::ranlux48;
0030
0031 namespace ActsTests {
0032
0033 BOOST_AUTO_TEST_SUITE(PhysicsSuite)
0034
0035 BOOST_DATA_TEST_CASE(NoPhoton, Dataset::parametersPhotonConversion, phi, theta,
0036                      seed) {
0037   using namespace Acts::UnitLiterals;
0038
0039   Generator gen(seed);
0040
0041   /// Produce not a photon
0042   ActsFatras::Particle particle =
0043       Dataset::makeParticle(Acts::PdgParticle::eElectron, phi, theta, 1_GeV);
0044   ActsFatras::Particle particleInit = particle;
0045
0046   ActsFatras::PhotonConversion pc;
0047
0048   // No limits should be set
0049   std::pair<double, double> limits;
0050   limits = pc.generatePathLimits(gen, particle);
0051   BOOST_CHECK_EQUAL(limits.first, std::numeric_limits<double>::infinity());
0052   BOOST_CHECK_EQUAL(limits.second, std::numeric_limits<double>::infinity());
0053
0054   // No particles should be generated
0055   std::vector<ActsFatras::Particle> generated;
0056   BOOST_CHECK(!pc.run(gen, particle, generated));
0057   BOOST_CHECK(generated.empty());
0058   // Particle shouldn't be modified
0059   BOOST_CHECK_EQUAL(particle.fourPosition(), particleInit.fourPosition());
0060   BOOST_CHECK_EQUAL(particle.fourMomentum(), particleInit.fourMomentum());
0061   BOOST_CHECK_EQUAL(particle.process(), particleInit.process());
0062   BOOST_CHECK_EQUAL(particle.properTime(), particleInit.properTime());
0063   BOOST_CHECK_EQUAL(particle.pathInX0(), particleInit.pathInX0());
0064   BOOST_CHECK_EQUAL(particle.pathInL0(), particleInit.pathInL0());
0065 }
0066
0067 BOOST_DATA_TEST_CASE(DeadPhoton, Dataset::parametersPhotonConversion, phi,
0068                      theta, seed) {
0069   using namespace Acts::UnitLiterals;
0070
0071   Generator gen(seed);
0072
0073   /// Produce a dead photon
0074   ActsFatras::Particle particle =
0075       Dataset::makeParticle(Acts::PdgParticle::eGamma, phi, theta, 0);
0076   ActsFatras::Particle particleInit = particle;
0077
0078   ActsFatras::PhotonConversion pc;
0079
0080   // No limits should be set - momentum too low
0081   std::pair<double, double> limits = pc.generatePathLimits(gen, particle);
0082   BOOST_CHECK_EQUAL(limits.first, std::numeric_limits<double>::infinity());
0083   BOOST_CHECK_EQUAL(limits.second, std::numeric_limits<double>::infinity());
0084
0085   // No particles should be generated - momentum too low
0086   std::vector<ActsFatras::Particle> generated;
0087   BOOST_CHECK(!pc.run(gen, particle, generated));
0088   BOOST_CHECK(generated.empty());
0089   // Particle shouldn't be modified
0090   BOOST_CHECK_EQUAL(particle.fourPosition(), particleInit.fourPosition());
0091   BOOST_CHECK_EQUAL(particle.fourMomentum(), particleInit.fourMomentum());
0092   BOOST_CHECK_EQUAL(particle.process(), particleInit.process());
0093   BOOST_CHECK_EQUAL(particle.properTime(), particleInit.properTime());
0094   BOOST_CHECK_EQUAL(particle.pathInX0(), particleInit.pathInX0());
0095   BOOST_CHECK_EQUAL(particle.pathInL0(), particleInit.pathInL0());
0096 }
0097
0098 BOOST_DATA_TEST_CASE(LowMomentumPhoton, Dataset::parametersPhotonConversion,
0099                      phi, theta, seed) {
0100   using namespace Acts::UnitLiterals;
0101
0102   Generator gen(seed);
0103
0104   /// Produce a low momentum photon
0105   ActsFatras::Particle particle =
0106       Dataset::makeParticle(Acts::PdgParticle::eGamma, phi, theta, 1_keV);
0107   ActsFatras::Particle particleInit = particle;
0108
0109   ActsFatras::PhotonConversion pc;
0110
0111   // No limits should be set - momentum too low
0112   std::pair<double, double> limits = pc.generatePathLimits(gen, particle);
0113   BOOST_CHECK_EQUAL(limits.first, std::numeric_limits<double>::infinity());
0114   BOOST_CHECK_EQUAL(limits.second, std::numeric_limits<double>::infinity());
0115
0116   // No particles should be generated - momentum too low
0117   std::vector<ActsFatras::Particle> generated;
0118   BOOST_CHECK(!pc.run(gen, particle, generated));
0119   BOOST_CHECK(generated.empty());
0120   // Particle shouldn't be modified
0121   BOOST_CHECK_EQUAL(particle.fourPosition(), particleInit.fourPosition());
0122   BOOST_CHECK_EQUAL(particle.fourMomentum(), particleInit.fourMomentum());
0123   BOOST_CHECK_EQUAL(particle.process(), particleInit.process());
0124   BOOST_CHECK_EQUAL(particle.properTime(), particleInit.properTime());
0125   BOOST_CHECK_EQUAL(particle.pathInX0(), particleInit.pathInX0());
0126   BOOST_CHECK_EQUAL(particle.pathInL0(), particleInit.pathInL0());
0127 }
0128
0129 BOOST_DATA_TEST_CASE(HighMomentumPhoton, Dataset::parametersPhotonConversion,
0130                      phi, theta, seed) {
0131   using namespace Acts::UnitLiterals;
0132
0133   Generator gen(seed);
0134
0135   /// Produce a high momentum photon
0136   ActsFatras::Particle particle =
0137       Dataset::makeParticle(Acts::PdgParticle::eGamma, phi, theta, 1_GeV);
0138   ActsFatras::Particle particleInit = particle;
0139
0140   ActsFatras::PhotonConversion pc;
0141
0142   // No limits should be set - momentum too low
0143   std::pair<double, double> limits = pc.generatePathLimits(gen, particle);
0144   BOOST_CHECK_NE(limits.first, std::numeric_limits<double>::infinity());
0145   BOOST_CHECK_EQUAL(limits.second, std::numeric_limits<double>::infinity());
0146
0147   // No particles should be generated - momentum too low
0148   std::vector<ActsFatras::Particle> generated;
0149   BOOST_CHECK(pc.run(gen, particle, generated));
0150   BOOST_CHECK_EQUAL(generated.size(), 2);
0151
0152   // Test the children
0153   BOOST_CHECK((generated[0].pdg() == Acts::PdgParticle::eElectron) ||
0154               (generated[0].pdg() == Acts::PdgParticle::ePositron));
0155   BOOST_CHECK((generated[1].pdg() == Acts::PdgParticle::eElectron) ||
0156               (generated[1].pdg() == Acts::PdgParticle::ePositron));
0157   BOOST_CHECK_NE(generated[0].pdg(), generated[1].pdg());
0158   BOOST_CHECK_NE(generated[0].fourMomentum(), Acts::Vector4::Zero());
0159   BOOST_CHECK_NE(generated[1].fourMomentum(), Acts::Vector4::Zero());
0160
0161   // Test for similar invariant masses
0162   Acts::Vector4 momSum =
0163       generated[0].fourMomentum() + generated[1].fourMomentum();
0164   Acts::Vector3 momVector = momSum.template segment<3>(Acts::eMom0);
0165   double sSum = momSum[Acts::eEnergy] * momSum[Acts::eEnergy] -
0166                 momVector.norm() * momVector.norm();
0167   BOOST_CHECK(std::isfinite(sSum));
0168
0169   double sParticle =
0170       particleInit.energy() * particleInit.energy() -
0171       particleInit.absoluteMomentum() * particleInit.absoluteMomentum();
0172   BOOST_CHECK(std::isfinite(sParticle));
0173   CHECK_CLOSE_OR_SMALL(sSum, sParticle, 1e-2, 1e-2);
0174 }
0175
0176 BOOST_AUTO_TEST_SUITE_END()
0177
0178 }  // namespace ActsTests