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 <iosfwd>
#include <map>
#include <vector>

#include "TObject.h"
#include "TString.h"
#include "LauAbsRValue.hh"
#include "LauBlind.hh"


class LauParameter : public TObject, public LauAbsRValue {

        public:
                LauParameter();


                explicit LauParameter(const TString& parName);


                explicit 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 Bool_t blind() const {return (blinder_ != 0);}


                inline const LauBlind* blinder() const {return blinder_;}


                inline Double_t value() const {return value_;}


                inline Double_t unblindValue() const {return (blinder_==0) ? value_ : blinder_->unblind(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 secondStage() const {return secondStage_;}


                inline Bool_t gaussConstraint() const {return gaussConstraint_;}


                inline Double_t constraintMean() const {return constraintMean_;}


                inline Double_t constraintWidth() const {return constraintWidth_;}


                inline Double_t globalCorrelationCoeff() const {return gcc_;}


                inline Double_t bias() const {return bias_;}


                inline Double_t pull() const {return pull_;}


                inline Bool_t isLValue() const {return kTRUE;}


                std::vector<LauParameter*> getPars();

                // 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 globalCorrelationCoeff(Double_t newGCCValue);


                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 secondStage(Bool_t secondStagePar);


                void addGaussianConstraint(Double_t newGaussMean, Double_t newGaussWidth);

                void removeGaussianConstraint();


                void blindParameter(const TString& blindingString, const Double_t width);

                // 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);


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

                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 void wipeClones() {clones_.clear();}


                void updateClones(Bool_t justValue);

        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 secondStage_;

                Bool_t gaussConstraint_;
                Double_t constraintMean_;
                Double_t constraintWidth_;

                Double_t gcc_;

                Double_t bias_;
                Double_t pull_;

                Bool_t clone_;

                LauParameter* parent_;

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

                LauBlind* blinder_;

                ClassDef(LauParameter, 3)

};

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

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

#endif