StepLimits.h

Go to the documentation of this file.

//****************************************************************************
//*                   This file is part of PandaRoot.                        *
//*                                                                          *
//*            PandaRoot is distributed under the terms of the               *
//*              GNU General Public License (GPL) version 3,                 *
//*                 copied verbatim in the file "LICENSE".                   *
//*                                                                          *
//*  Copyright (C) 2006 - 2024 FAIR GmbH and copyright holders of PandaRoot  *
//*     The copyright holders are listed in the file "COPYRIGHTHOLDERS".     *
//*               The authors are listed in the file "AUTHORS".              *
//****************************************************************************

/* Copyright 2008-2014, Technische Universitaet Muenchen,
   Authors: Christian Hoeppner & Sebastian Neubert & Johannes Rauch

   This file is part of GENFIT.

   GENFIT is free software: you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published
   by the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   GENFIT is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public License
   along with GENFIT.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef genfit_StepLimits_h
#define genfit_StepLimits_h

#include <vector>
#include <math.h>

namespace genfit {

enum StepLimitType {
  // soft limits (only rough estimation, can go beyond safely)
  stp_noLimit = 0, // only for internal use

  // medium limits (can go a bit further if e.g. plane or boundary will be reached)
  stp_fieldCurv, // stepsize limited by curvature and magnetic field inhomogenities
  stp_momLoss,   // stepsize limited by stepper because maximum momLoss is reached
  stp_sMax,      // stepsize limited by SMax defined in #estimateStep()

  // hard limits (must stop there at any case!)
  stp_sMaxArg,  // stepsize limited by argument maxStepArg passed to #estimateStep()
  stp_boundary, // stepsize limited by stepper because material boundary is encountered
  stp_plane,    // stepsize limited because destination plane is reached

  ENUM_NR_ITEMS // only for internal use
};

class StepLimits {

 public:
  StepLimits() : limits_(ENUM_NR_ITEMS, maxLimit_), stepSign_(1) { ; }

  StepLimits &operator=(const StepLimits &other);

  double getLimit(StepLimitType type) const { return limits_[type]; }
  double getLimitSigned(StepLimitType type) const { return stepSign_ * getLimit(type); }

  std::pair<StepLimitType, double> getLowestLimit(double margin = 1.E-3) const;

  double getLowestLimitVal(double margin = 1.E-3) const;
  double getLowestLimitSignedVal(double margin = 1.E-3) const { return getLowestLimitVal(margin) * stepSign_; }

  char getStepSign() const { return stepSign_; } // +- 1

  void reduceLimit(StepLimitType type, double value);
  void setLimit(StepLimitType type, double value) { limits_[type] = fabs(value); }
  void setStepSign(char signedVal);
  void setStepSign(double signedVal);

  void removeLimit(StepLimitType type) { limits_[type] = maxLimit_; }

  void reset();
  void Print();

 private:
  std::vector<double> limits_; // limits are unsigned (i.e. non-negative)
  signed char stepSign_;
  static const double maxLimit_;
};

} /* End of namespace genfit */
#endif // genfit_StepLimits_h