Charge.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file Charge.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2020 CERN for the benefit of the Acts project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#pragma once

#include "Acts/Utilities/Units.hpp"

#include <cassert>
#include <cmath>

namespace Acts {


struct Neutral {
  Neutral() = default;
  template <typename T>
  constexpr Neutral(T absQ) noexcept {
    assert((absQ == 0.0f) and "Input charge must be zero");
    // suppress `unused variable` warning in non-debug builds
    (void)(absQ);
  }

  template <typename T>
  constexpr T extractCharge(T /* pInv */) const noexcept {
    return 0;
  }
  template <typename T>
  constexpr T extractMomentum(T pInv) const noexcept {
    // the abs is not strictly needed. it is added to protect against invalid,
    // i.e. negative, 1/p values to ensure that the output is still correct.
    return std::abs(1 / pInv);
  }

  friend constexpr bool operator==(Neutral, Neutral) noexcept { return true; }
};

struct SinglyCharged {
  SinglyCharged() = default;
  template <typename T>
  constexpr SinglyCharged(T absQ) noexcept {
    assert((absQ == static_cast<T>(UnitConstants::e)) and
           "Input charge magnitude must be e");
    // suppress `unused variable` warning in non-debug builds
    (void)(absQ);
  }

  template <typename T>
  constexpr T extractCharge(T qOverP) const noexcept {
    return std::copysign(static_cast<T>(UnitConstants::e), qOverP);
  }
  template <typename T>
  constexpr T extractMomentum(T qOverP) const noexcept {
    return std::abs(static_cast<T>(UnitConstants::e) / qOverP);
  }

  friend constexpr bool operator==(SinglyCharged, SinglyCharged) noexcept {
    return true;
  }
};

class AnyCharge {
 public:
  AnyCharge() = delete;
  template <typename T>
  constexpr AnyCharge(T absQ) noexcept : m_magnitude(std::abs(absQ)) {
    assert((0 <= absQ) and "Input charge magnitude must be zero or positive");
  }

  template <typename T>
  constexpr T extractCharge(T qOverP) const noexcept {
    return std::copysign(static_cast<T>(m_magnitude), qOverP);
  }
  template <typename T>
  constexpr T extractMomentum(T qOverP) const noexcept {
    return (m_magnitude != 0.0f)
               ? std::abs(static_cast<T>(m_magnitude) / qOverP)
               : std::abs(1 / qOverP);
  }

 private:
  float m_magnitude;

  friend constexpr bool operator==(AnyCharge lhs, AnyCharge rhs) noexcept {
    return lhs.m_magnitude == rhs.m_magnitude;
  }
};


}  // namespace Acts