ConstrainedStep.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2018-2022 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/Algebra.hpp"

#include <algorithm>
#include <array>
#include <cassert>
#include <cmath>
#include <iomanip>
#include <limits>
#include <ostream>
#include <sstream>

namespace Acts {

class ConstrainedStep {
 public:
  using Scalar = ActsScalar;

  enum Type : int { actor = 0, aborter = 1, user = 2 };

  size_t nStepTrials = std::numeric_limits<size_t>::max();

  constexpr ConstrainedStep() = default;

  constexpr explicit ConstrainedStep(Scalar value) { setUser(value); }

  constexpr void setAccuracy(Scalar value) {
    assert(value > 0 && "ConstrainedStep accuracy must be > 0.");
    // set the accuracy value
    m_accuracy = value;
  }

  constexpr void setUser(Scalar value) {
    // TODO enable assert; see https://github.com/acts-project/acts/issues/2543
    // assert(value != 0 && "ConstrainedStep user must be != 0.");
    // set the user value
    m_values[user] = value;
  }

  constexpr Scalar value() const {
    Scalar min = *std::min_element(m_values.begin(), m_values.end());
    // accuracy is always positive and therefore handled separately
    Scalar result = std::min(std::abs(min), m_accuracy);
    return std::signbit(min) ? -result : result;
  }

  constexpr Scalar value(Type type) const { return m_values[type]; }

  constexpr Scalar accuracy() const { return m_accuracy; }

  constexpr void release(Type type) { m_values[type] = kNotSet; }

  constexpr void releaseAccuracy() { m_accuracy = kNotSet; }

  constexpr void update(Scalar value, Type type, bool releaseStep = false) {
    if (releaseStep) {
      release(type);
    }
    // check the current value and set it if appropriate
    // this will also allow signed values due to overstepping
    if (std::abs(value) < std::abs(m_values[type])) {
      // TODO enable assert; see
      // https://github.com/acts-project/acts/issues/2543
      // assert(value != 0 && "ConstrainedStep user must be != 0.");
      m_values[type] = value;
    }
  }

  std::ostream& toStream(std::ostream& os) const {
    // Helper method to avoid unreadable screen output
    auto streamValue = [&](Scalar val) {
      os << std::setw(5);
      if (std::abs(val) == kNotSet) {
        os << (val > 0 ? "+∞" : "-∞");
      } else {
        os << val;
      }
    };

    os << "(";
    streamValue(m_accuracy);
    os << ", ";
    streamValue(value(actor));
    os << ", ";
    streamValue(value(aborter));
    os << ", ";
    streamValue(value(user));
    os << ")";

    return os;
  }

  std::string toString() const {
    std::stringstream dstream;
    toStream(dstream);
    return dstream.str();
  }

 private:
  inline static constexpr auto kNotSet = std::numeric_limits<Scalar>::max();

  std::array<Scalar, 3> m_values = {kNotSet, kNotSet, kNotSet};
  Scalar m_accuracy = kNotSet;
};

inline std::ostream& operator<<(std::ostream& os, const ConstrainedStep& step) {
  return step.toStream(os);
}

}  // namespace Acts