LauParameter.hh

Go to the documentation of this file.

 
/*
Copyright 2006 University of Warwick
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
    http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
 
/*
Laura++ package authors:
John Back
Paul Harrison
Thomas Latham
*/
 
#ifndef LAU_PARAMETER
#define LAU_PARAMETER
 
#include "LauAbsRValue.hh"
#include "LauBlind.hh"
 
#include "TObject.h"
#include "TString.h"
 
#include <iosfwd>
#include <map>
#include <vector>
 
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_; }
 
 
    Double_t constraintPenalty() const;
 
 
    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 generateConstraintMean();
 
 
    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;
 
    friend class LauFitObject;
 
    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 constraintTrueMean_;
    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, 4 )
};
 
std::ostream& operator<<( std::ostream& stream, const LauParameter& par );
 
typedef std::vector<std::vector<LauParameter>> LauParArray;
 
#endif