LauParameter.hh

Go to the documentation of this file.

// Copyright University of Warwick 2006 - 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

// Authors:
// Thomas Latham
// John Back
// Paul Harrison

#ifndef LAU_PARAMETER
#define LAU_PARAMETER

#include <map>
#include <vector>

#include "TString.h"


class LauParameter {

        public:
                LauParameter();


                LauParameter(const TString& parName);


                LauParameter(Double_t parValue);


                LauParameter(Double_t parValue, Double_t min, Double_t max);


                LauParameter(Double_t parValue, Double_t min, Double_t max, Bool_t parFixed);


                LauParameter(Double_t parValue, Double_t parError, Double_t min, Double_t max);


                LauParameter(const TString& parName, Double_t parValue);


                LauParameter(const TString& parName, Double_t parValue, Double_t min, Double_t max);


                LauParameter(const TString& parName, Double_t parValue, Double_t min, Double_t max, Bool_t parFixed);


                LauParameter(const TString& parName, Double_t parValue, Double_t parError, Double_t min, Double_t max);

                // Destructor
                virtual ~LauParameter(){}


                LauParameter(const LauParameter& rhs);


                LauParameter& operator=(const LauParameter& rhs);

                // the simple accessor functions


                inline const TString& name() const {return name_;}


                inline Double_t value() const {return value_;}


                inline Double_t error() const {return error_;}


                inline Double_t negError() const {return negError_;}


                inline Double_t posError() const {return posError_;}


                inline Double_t genValue() const {return genValue_;}


                inline Double_t initValue() const {return initValue_;}


                inline Double_t minValue() const {return minValue_;}


                inline Double_t maxValue() const {return maxValue_;}


                inline Double_t range() const {return this->maxValue() - this->minValue();}


                inline Bool_t fixed() const {return fixed_;}


                inline Bool_t firstStage() const {return firstStage_;}


                inline Bool_t secondStage() const {return secondStage_;}


                inline Double_t bias() const {return bias_;}


                inline Double_t pull() const {return pull_;}

                // the simple "setter" functions


                void name(const TString& newName);


                void value(Double_t newValue);


                void error(Double_t newError);


                void negError(Double_t newNegError);


                void posError(Double_t newPosError);


                void errors(Double_t newError, Double_t newNegError, Double_t newPosError);


                void valueAndErrors(Double_t newValue, Double_t newError, Double_t newNegError = 0.0, Double_t newPosError = 0.0);


                void genValue(Double_t newGenValue);


                void initValue(Double_t newInitValue);


                void minValue(Double_t newMinValue);


                void maxValue(Double_t newMaxValue);


                void range(Double_t newMinValue, Double_t newMaxValue);


                void valueAndRange(Double_t newValue, Double_t newMinValue, Double_t newMaxValue);


                void fixed(Bool_t parFixed);


                void firstStage(Bool_t firstStagePar);


                void secondStage(Bool_t secondStagePar);

                // operators


                LauParameter& operator = (Double_t val);


                LauParameter& operator += (Double_t val);


                LauParameter& operator -= (Double_t val);


                LauParameter& operator *= (Double_t val);


                LauParameter& operator /= (Double_t val);

                // functions for the cloning mechanism


                inline Bool_t clone() const {return clone_;}


                LauParameter* createClone(Double_t constFactor = 1.0);


                LauParameter* createClone(const TString& newName, Double_t constFactor = 1.0);

                void updatePull();


                void randomiseValue();


                void randomiseValue(Double_t minVal, Double_t maxVal);

        protected:

                void checkRange(Double_t val, Double_t minVal, Double_t maxVal);

                inline void checkRange()
                {
                        this->checkRange(this->value(),this->minValue(),this->maxValue());
                }


                inline void clone(LauParameter* theparent) {
                        parent_ = theparent;
                        clone_ = (parent_==0) ? kFALSE : kTRUE;
                }


                inline LauParameter* parent() const {return parent_;}

                inline void wipeClones() {clones_.clear();}


                void updateClones(Bool_t justValue = kFALSE);

        private:
                friend class LauFitNtuple;

                TString name_;

                Double_t value_;

                Double_t error_;
                Double_t negError_;
                Double_t posError_;

                Double_t genValue_;

                Double_t initValue_;
                Double_t minValue_;
                Double_t maxValue_;
                Bool_t fixed_;
                Bool_t firstStage_;
                Bool_t secondStage_;

                Double_t bias_;
                Double_t pull_;

                Bool_t clone_;
                LauParameter* parent_;

                std::map<LauParameter*, Double_t> clones_;

                ClassDef(LauParameter, 0)

};

// operators to allow mathematical operations with double precision numbers
Double_t operator + (const LauParameter& lhs, Double_t rhs);
Double_t operator + (Double_t lhs, const LauParameter& rhs);
Double_t operator + (const LauParameter& lhs, const LauParameter& rhs);
Double_t operator - (const LauParameter& lhs, Double_t rhs);
Double_t operator - (Double_t lhs, const LauParameter& rhs);
Double_t operator - (const LauParameter& lhs, const LauParameter& rhs);
Double_t operator * (const LauParameter& lhs, Double_t rhs);
Double_t operator * (Double_t lhs, const LauParameter& rhs);
Double_t operator * (const LauParameter& lhs, const LauParameter& rhs);
Double_t operator / (const LauParameter& lhs, Double_t rhs);
Double_t operator / (Double_t lhs, const LauParameter& rhs);
Double_t operator / (const LauParameter& lhs, const LauParameter& rhs);
Double_t operator += (Double_t& lhs, const LauParameter& rhs);
Double_t operator -= (Double_t& lhs, const LauParameter& rhs);
Double_t operator *= (Double_t& lhs, const LauParameter& rhs);
Double_t operator /= (Double_t& lhs, const LauParameter& rhs);

ostream& operator << (ostream& stream, const LauParameter& par);

typedef std::vector< std::vector<LauParameter> >  LauParArray;

#endif