StepLimits.h

/* 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(const StepLimits&) = default;
 
  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