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 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/Definitions.hpp"

#include <algorithm>
#include <array>
#include <iomanip>
#include <limits>
#include <sstream>

namespace Acts {

struct ConstrainedStep {
  enum Type : int { accuracy = 0, actor = 1, aborter = 2, user = 3 };

  std::array<double, 4> values = {
      {std::numeric_limits<double>::max(), std::numeric_limits<double>::max(),
       std::numeric_limits<double>::max(), std::numeric_limits<double>::max()}};

  NavigationDirection direction = forward;

  void update(const double& value, Type type, bool releaseStep = false) {
    if (releaseStep) {
      release(type);
    }
    // The check the current value and set it if appropriate
    double cValue = values[type];
    values[type] = cValue * cValue < value * value ? cValue : value;
  }

  void release(Type type) {
    double mvalue = (direction == forward)
                        ? (*std::max_element(values.begin(), values.end()))
                        : (*std::min_element(values.begin(), values.end()));
    values[type] = mvalue;
  }

  ConstrainedStep(double value) : direction(value > 0. ? forward : backward) {
    values[accuracy] *= direction;
    values[actor] *= direction;
    values[aborter] *= direction;
    values[user] = value;
  }

  ConstrainedStep& operator=(const double& value) {
    values[accuracy] = value;
    // set/update the direction
    direction = value > 0. ? forward : backward;
    return (*this);
  }

  operator double() const {
    if (direction == forward) {
      return (*std::min_element(values.begin(), values.end()));
    }
    return (*std::max_element(values.begin(), values.end()));
  }

  double value(Type type) const { return values[type]; }

  double max() const {
    return (*std::max_element(values.begin(), values.end()));
  }

  double min() const {
    return (*std::min_element(values.begin(), values.end()));
  }

  Type currentType() const {
    if (direction == forward) {
      return Type(std::min_element(values.begin(), values.end()) -
                  values.begin());
    }
    return Type(std::max_element(values.begin(), values.end()) -
                values.begin());
  }

  std::string toString() const;
};

inline std::string ConstrainedStep::toString() const {
  std::stringstream dstream;

  // Helper method to avoid unreadable screen output
  auto streamValue = [&](ConstrainedStep cstep) -> void {
    double val = values[cstep];
    dstream << std::setw(5);
    if (std::abs(val) == std::numeric_limits<double>::max()) {
      dstream << (val > 0 ? "+∞" : "-∞");
    } else {
      dstream << val;
    }
  };

  dstream << "(";
  streamValue(accuracy);
  dstream << ", ";
  streamValue(actor);
  dstream << ", ";
  streamValue(aborter);
  dstream << ", ";
  streamValue(user);
  dstream << " )";
  return dstream.str();
}

}  // namespace Acts