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/Definitions/Units.hpp"
#include "Acts/EventData/ChargeConcept.hpp"
#include "Acts/Utilities/Concepts.hpp"

#include <cassert>
#include <cmath>

namespace Acts {


struct Neutral {
  constexpr Neutral() = default;

  // TODO remove this method after grad refactor; currently track parameters
  // depend on it
  constexpr Neutral(float absQ) noexcept {
    assert((absQ == 0) and "Input charge must be zero");
    (void)absQ;
  }

  constexpr float absQ() const noexcept { return 0; }

  template <typename T>
  constexpr auto extractCharge(T /*qOverP*/) const noexcept {
    return 0.0f;
  }

  template <typename T>
  constexpr auto extractMomentum(T qOverP) const noexcept {
    assert(qOverP >= 0 && "qOverP cannot be negative");
    return 1.0f / qOverP;
  }

  template <typename P, typename Q>
  constexpr auto qOverP(P momentum, Q signedQ) const noexcept {
    assert((signedQ != 0) and "charge must be 0");
    (void)signedQ;
    return 1.0f / momentum;
  }

  friend constexpr bool operator==(Neutral /*lhs*/, Neutral /*rhs*/) noexcept {
    return true;
  }
};

ACTS_STATIC_CHECK_CONCEPT(ChargeConcept, Neutral);

struct SinglyCharged {
  constexpr SinglyCharged() = default;

  // TODO remove this method after grad refactor; currently track parameters
  // depend on it
  constexpr SinglyCharged(float absQ) noexcept {
    assert((absQ == UnitConstants::e) and "Input charge magnitude must be e");
    (void)absQ;
  }

  constexpr float absQ() const noexcept { return UnitConstants::e; }

  template <typename T>
  constexpr auto extractCharge(T qOverP) const noexcept {
    // using because of autodiff
    using std::copysign;
    return copysign(UnitConstants::e, qOverP);
  }

  template <typename T>
  constexpr auto extractMomentum(T qOverP) const noexcept {
    // using because of autodiff
    using std::abs;
    return extractCharge(qOverP) / qOverP;
  }

  template <typename P, typename Q>
  constexpr auto qOverP(P momentum, Q signedQ) const noexcept {
    using std::abs;
    assert((abs(signedQ) == UnitConstants::e) && "absolute charge must be e");
    return signedQ / momentum;
  }

  friend constexpr bool operator==(SinglyCharged /*lhs*/,
                                   SinglyCharged /*rhs*/) noexcept {
    return true;
  }
};

ACTS_STATIC_CHECK_CONCEPT(ChargeConcept, SinglyCharged);

class NonNeutralCharge {
 public:
  constexpr NonNeutralCharge(float absQ) noexcept : m_absQ{absQ} {
    assert((0 < absQ) and "Input charge magnitude must be positive");
  }
  constexpr NonNeutralCharge(SinglyCharged /*unused*/) noexcept
      : m_absQ{UnitConstants::e} {}

  constexpr float absQ() const noexcept { return m_absQ; }

  template <typename T>
  constexpr auto extractCharge(T qOverP) const noexcept {
    // using because of autodiff
    using std::copysign;
    return copysign(m_absQ, qOverP);
  }
  template <typename T>
  constexpr auto extractMomentum(T qOverP) const noexcept {
    // using because of autodiff
    using std::abs;
    return extractCharge(qOverP) / qOverP;
  }

  template <typename P, typename Q>
  constexpr auto qOverP(P momentum, Q signedQ) const noexcept {
    // using because of autodiff
    using std::abs;
    assert(abs(signedQ) == m_absQ && "inconsistent charge");
    return signedQ / momentum;
  }

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

 private:
  float m_absQ{};
};

ACTS_STATIC_CHECK_CONCEPT(ChargeConcept, NonNeutralCharge);

class AnyCharge {
 public:
  constexpr AnyCharge(float absQ) noexcept : m_absQ{absQ} {
    assert((0 <= absQ) and "Input charge magnitude must be zero or positive");
  }
  constexpr AnyCharge(SinglyCharged /*unused*/) noexcept
      : m_absQ{UnitConstants::e} {}
  constexpr AnyCharge(Neutral /*unused*/) noexcept {}

  constexpr float absQ() const noexcept { return m_absQ; }

  template <typename T>
  constexpr auto extractCharge(T qOverP) const noexcept {
    // using because of autodiff
    using std::copysign;
    return copysign(m_absQ, qOverP);
  }
  template <typename T>
  constexpr auto extractMomentum(T qOverP) const noexcept {
    // using because of autodiff
    using std::abs;
    return (m_absQ != 0.0f) ? extractCharge(qOverP) / qOverP : 1.0f / qOverP;
  }

  template <typename P, typename Q>
  constexpr auto qOverP(P momentum, Q signedQ) const noexcept {
    // using because of autodiff
    using std::abs;
    assert(abs(signedQ) == m_absQ && "inconsistent charge");
    return (m_absQ != 0.0f) ? signedQ / momentum : 1.0f / momentum;
  }

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

 private:
  float m_absQ{};
};

ACTS_STATIC_CHECK_CONCEPT(ChargeConcept, AnyCharge);


}  // namespace Acts