Fatras/Physics/PhotonConversionTests.cpp

0001 // This file is part of the Acts project.
0002 //
0003 // Copyright (C) 2021 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 http://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 "Acts/Tests/CommonHelpers/FloatComparisons.hpp"
0017 #include "ActsFatras/EventData/Particle.hpp"
0018 #include "ActsFatras/Physics/ElectroMagnetic/PhotonConversion.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 BOOST_AUTO_TEST_SUITE(FatrasPhotonConversion)
0032
0033 BOOST_DATA_TEST_CASE(NoPhoton, Dataset::parametersPhotonConversion, phi, lambda,
0034                      seed) {
0035   using Scalar = ActsFatras::PhotonConversion::Scalar;
0036   using namespace Acts::UnitLiterals;
0037
0038   Generator gen(seed);
0039
0040   /// Produce not a photon
0041   ActsFatras::Particle particle =
0042       Dataset::makeParticle(Acts::PdgParticle::eElectron, phi, lambda, 1_GeV);
0043   ActsFatras::Particle particleInit = particle;
0044
0045   ActsFatras::PhotonConversion pc;
0046
0047   // No limits should be set
0048   std::pair<Scalar, Scalar> limits;
0049   limits = pc.generatePathLimits(gen, particle);
0050   BOOST_CHECK_EQUAL(limits.first, std::numeric_limits<Scalar>::infinity());
0051   BOOST_CHECK_EQUAL(limits.second, std::numeric_limits<Scalar>::infinity());
0052
0053   // No particles should be generated
0054   std::vector<ActsFatras::Particle> generated;
0055   BOOST_CHECK(!pc.run(gen, particle, generated));
0056   BOOST_CHECK(generated.empty());
0057   // Particle shouldn't be modified
0058   BOOST_CHECK_EQUAL(particle.fourPosition(), particleInit.fourPosition());
0059   BOOST_CHECK_EQUAL(particle.fourMomentum(), particleInit.fourMomentum());
0060   BOOST_CHECK_EQUAL(particle.process(), particleInit.process());
0061   BOOST_CHECK_EQUAL(particle.properTime(), particleInit.properTime());
0062   BOOST_CHECK_EQUAL(particle.pathInX0(), particleInit.pathInX0());
0063   BOOST_CHECK_EQUAL(particle.pathInL0(), particleInit.pathInL0());
0064 }
0065
0066 BOOST_DATA_TEST_CASE(DeadPhoton, Dataset::parametersPhotonConversion, phi,
0067                      lambda, seed) {
0068   using Scalar = ActsFatras::PhotonConversion::Scalar;
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, lambda, 0);
0076   ActsFatras::Particle particleInit = particle;
0077
0078   ActsFatras::PhotonConversion pc;
0079
0080   // No limits should be set - momentum too low
0081   std::pair<Scalar, Scalar> limits = pc.generatePathLimits(gen, particle);
0082   BOOST_CHECK_EQUAL(limits.first, std::numeric_limits<Scalar>::infinity());
0083   BOOST_CHECK_EQUAL(limits.second, std::numeric_limits<Scalar>::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, lambda, seed) {
0100   using Scalar = ActsFatras::PhotonConversion::Scalar;
0101   using namespace Acts::UnitLiterals;
0102
0103   Generator gen(seed);
0104
0105   /// Produce a low momentum photon
0106   ActsFatras::Particle particle =
0107       Dataset::makeParticle(Acts::PdgParticle::eGamma, phi, lambda, 1_keV);
0108   ActsFatras::Particle particleInit = particle;
0109
0110   ActsFatras::PhotonConversion pc;
0111
0112   // No limits should be set - momentum too low
0113   std::pair<Scalar, Scalar> limits = pc.generatePathLimits(gen, particle);
0114   BOOST_CHECK_EQUAL(limits.first, std::numeric_limits<Scalar>::infinity());
0115   BOOST_CHECK_EQUAL(limits.second, std::numeric_limits<Scalar>::infinity());
0116
0117   // No particles should be generated - momentum too low
0118   std::vector<ActsFatras::Particle> generated;
0119   BOOST_CHECK(!pc.run(gen, particle, generated));
0120   BOOST_CHECK(generated.empty());
0121   // Particle shouldn't be modified
0122   BOOST_CHECK_EQUAL(particle.fourPosition(), particleInit.fourPosition());
0123   BOOST_CHECK_EQUAL(particle.fourMomentum(), particleInit.fourMomentum());
0124   BOOST_CHECK_EQUAL(particle.process(), particleInit.process());
0125   BOOST_CHECK_EQUAL(particle.properTime(), particleInit.properTime());
0126   BOOST_CHECK_EQUAL(particle.pathInX0(), particleInit.pathInX0());
0127   BOOST_CHECK_EQUAL(particle.pathInL0(), particleInit.pathInL0());
0128 }
0129
0130 BOOST_DATA_TEST_CASE(HighMomentumPhoton, Dataset::parametersPhotonConversion,
0131                      phi, lambda, seed) {
0132   using Scalar = ActsFatras::PhotonConversion::Scalar;
0133   using namespace Acts::UnitLiterals;
0134
0135   Generator gen(seed);
0136
0137   /// Produce a high momentum photon
0138   ActsFatras::Particle particle =
0139       Dataset::makeParticle(Acts::PdgParticle::eGamma, phi, lambda, 1_GeV);
0140   ActsFatras::Particle particleInit = particle;
0141
0142   ActsFatras::PhotonConversion pc;
0143
0144   // No limits should be set - momentum too low
0145   std::pair<Scalar, Scalar> limits = pc.generatePathLimits(gen, particle);
0146   BOOST_CHECK_NE(limits.first, std::numeric_limits<Scalar>::infinity());
0147   BOOST_CHECK_EQUAL(limits.second, std::numeric_limits<Scalar>::infinity());
0148
0149   // No particles should be generated - momentum too low
0150   std::vector<ActsFatras::Particle> generated;
0151   BOOST_CHECK(pc.run(gen, particle, generated));
0152   BOOST_CHECK_EQUAL(generated.size(), 2);
0153
0154   // Test the children
0155   BOOST_CHECK((generated[0].pdg() == Acts::PdgParticle::eElectron) ||
0156               (generated[0].pdg() == Acts::PdgParticle::ePositron));
0157   BOOST_CHECK((generated[1].pdg() == Acts::PdgParticle::eElectron) ||
0158               (generated[1].pdg() == Acts::PdgParticle::ePositron));
0159   BOOST_CHECK_NE(generated[0].pdg(), generated[1].pdg());
0160   BOOST_CHECK_NE(generated[0].fourMomentum(), Acts::Vector4::Zero());
0161   BOOST_CHECK_NE(generated[1].fourMomentum(), Acts::Vector4::Zero());
0162
0163   // Test for similar invariant masses
0164   Acts::Vector4 momSum =
0165       generated[0].fourMomentum() + generated[1].fourMomentum();
0166   Acts::Vector3 momVector = momSum.template segment<3>(Acts::eMom0);
0167   double sSum = momSum[Acts::eEnergy] * momSum[Acts::eEnergy] -
0168                 momVector.norm() * momVector.norm();
0169   BOOST_CHECK(std::isfinite(sSum));
0170
0171   double sParticle =
0172       particleInit.energy() * particleInit.energy() -
0173       particleInit.absoluteMomentum() * particleInit.absoluteMomentum();
0174   BOOST_CHECK(std::isfinite(sParticle));
0175   CHECK_CLOSE_OR_SMALL(sSum, sParticle, 1e-2, 1e-2);
0176 }
0177
0178 BOOST_AUTO_TEST_SUITE_END()