MnUserTransformation.h

Go to the documentation of this file.

// @(#)root/minuit2:$Id$
// Authors: M. Winkler, F. James, L. Moneta, A. Zsenei   2003-2005
 
/**********************************************************************
 *                                                                    *
 * Copyright (c) 2005 LCG ROOT Math team,  CERN/PH-SFT                *
 *                                                                    *
 **********************************************************************/
 
#ifndef ROOT_Minuit2_MnUserTransformation
#define ROOT_Minuit2_MnUserTransformation
 
#include "Minuit2/MnConfig.h"
#include "Minuit2/MnMatrix.h"
#include "Minuit2/MinuitParameter.h"
#include "Minuit2/MnMachinePrecision.h"
#include "Minuit2/SinParameterTransformation.h"
#include "Minuit2/SqrtLowParameterTransformation.h"
#include "Minuit2/SqrtUpParameterTransformation.h"
 
#include <vector>
#include <string>
#include <cassert>
 
namespace ROOT {
 
namespace Minuit2 {
 
class MnUserCovariance;
 
// class MnMachinePrecision;
 
/**
    class dealing with the transformation  between user specified parameters (external) and
    internal parameters used for minimization
 */
 
class MnUserTransformation {
 
public:
   MnUserTransformation()
      : fPrecision(MnMachinePrecision()), fParameters(std::vector<MinuitParameter>()),
        fExtOfInt(std::vector<unsigned int>()), fDoubleLimTrafo(SinParameterTransformation()),
        fUpperLimTrafo(SqrtUpParameterTransformation()), fLowerLimTrafo(SqrtLowParameterTransformation()),
        fCache(std::vector<double>())
   {
   }
 
   MnUserTransformation(const std::vector<double> &, const std::vector<double> &);
 
   ~MnUserTransformation() {}
 
   MnUserTransformation(const MnUserTransformation &trafo)
      : fPrecision(trafo.fPrecision), fParameters(trafo.fParameters), fExtOfInt(trafo.fExtOfInt),
        fDoubleLimTrafo(trafo.fDoubleLimTrafo), fUpperLimTrafo(trafo.fUpperLimTrafo),
        fLowerLimTrafo(trafo.fLowerLimTrafo), fCache(trafo.fCache)
   {
   }
 
   MnUserTransformation &operator=(const MnUserTransformation &trafo)
   {
      if (this != &trafo) {
         fPrecision = trafo.fPrecision;
         fParameters = trafo.fParameters;
         fExtOfInt = trafo.fExtOfInt;
         fDoubleLimTrafo = trafo.fDoubleLimTrafo;
         fUpperLimTrafo = trafo.fUpperLimTrafo;
         fLowerLimTrafo = trafo.fLowerLimTrafo;
         fCache = trafo.fCache;
      }
      return *this;
   }
 
   //#ifdef MINUIT2_THREAD_SAFE
   // thread-safe version (do not use cache)
   std::vector<double> operator()(const MnAlgebraicVector &) const;
   //#else // not thread safe
   //   const std::vector<double>& operator()(const MnAlgebraicVector&) const;
   //#endif
 
   // Index = internal Parameter
   double Int2ext(unsigned int, double) const;
 
   // Index = internal Parameter
   double Int2extError(unsigned int, double, double) const;
 
   MnUserCovariance Int2extCovariance(const MnAlgebraicVector &, const MnAlgebraicSymMatrix &) const;
 
   // Index = external Parameter
   double Ext2int(unsigned int, double) const;
 
   // Index = internal Parameter
   double DInt2Ext(unsigned int, double) const;
 
   //   // Index = external Parameter
   //   double dExt2Int(unsigned int, double) const;
 
   // Index = external Parameter
   unsigned int IntOfExt(unsigned int) const;
 
   // Index = internal Parameter
   unsigned int ExtOfInt(unsigned int internal) const
   {
      assert(internal < fExtOfInt.size());
      return fExtOfInt[internal];
   }
 
   const std::vector<MinuitParameter> &Parameters() const { return fParameters; }
 
   unsigned int VariableParameters() const { return static_cast<unsigned int>(fExtOfInt.size()); }
 
   // return initial parameter values (useful especially to get fixed parameter values)
   const std::vector<double> &InitialParValues() const { return fCache; }
 
   /** forwarded interface */
 
   const MnMachinePrecision &Precision() const { return fPrecision; }
   void SetPrecision(double eps) { fPrecision.SetPrecision(eps); }
 
   /// access to parameters and errors in column-wise representation
 
   std::vector<double> Params() const;
   std::vector<double> Errors() const;
 
   // access to single Parameter
   const MinuitParameter &Parameter(unsigned int) const;
 
   // add free Parameter
   bool Add(const std::string &, double, double);
   // add limited Parameter
   bool Add(const std::string &, double, double, double, double);
   // add const Parameter
   bool Add(const std::string &, double);
 
   // interaction via external number of Parameter
   void Fix(unsigned int);
   void Release(unsigned int);
   void RemoveLimits(unsigned int);
   void SetValue(unsigned int, double);
   void SetError(unsigned int, double);
   void SetLimits(unsigned int, double, double);
   void SetUpperLimit(unsigned int, double);
   void SetLowerLimit(unsigned int, double);
   void SetName(unsigned int, const std::string &);
 
   double Value(unsigned int) const;
   double Error(unsigned int) const;
 
   // interaction via Name of Parameter
   void Fix(const std::string &);
   void Release(const std::string &);
   void SetValue(const std::string &, double);
   void SetError(const std::string &, double);
   void SetLimits(const std::string &, double, double);
   void SetUpperLimit(const std::string &, double);
   void SetLowerLimit(const std::string &, double);
   void RemoveLimits(const std::string &);
 
   double Value(const std::string &) const;
   double Error(const std::string &) const;
 
   // convert Name into external number of Parameter (will assert if parameter  is not found)
   unsigned int Index(const std::string &) const;
   // find parameter index given a name. If it is not found return a -1
   int FindIndex(const std::string &) const;
 
   // convert external number into Name of Parameter (will assert if index is out of range)
   const std::string &GetName(unsigned int) const;
   // mantain interface with const char * for backward compatibility
   const char *Name(unsigned int) const;
 
private:
   MnMachinePrecision fPrecision;
 
   std::vector<MinuitParameter> fParameters;
   std::vector<unsigned int> fExtOfInt;
 
   SinParameterTransformation fDoubleLimTrafo;
   SqrtUpParameterTransformation fUpperLimTrafo;
   SqrtLowParameterTransformation fLowerLimTrafo;
 
   mutable std::vector<double> fCache;
};
 
} // namespace Minuit2
 
} // namespace ROOT
 
#endif // ROOT_Minuit2_MnUserTransformation