StepLimits.h

Go to the documentation of this file.

/* 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