LauFitObject.hh

Go to the documentation of this file.

 
/*
Copyright 2013 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_FIT_OBJECT
#define LAU_FIT_OBJECT
 
#include "LauAbsFitter.hh"
#include "LauFormulaPar.hh"
 
#include "TMatrixD.h"
#include "TObject.h"
#include "TString.h"
#include "TVectorD.h"
 
#include <set>
#include <vector>
 
class LauFitObject : public TObject {
 
  public:
    virtual ~LauFitObject() = default;
 
 
    void useAsymmFitErrors( Bool_t useAsymmErrors ) { useAsymmFitErrors_ = useAsymmErrors; }
 
    Bool_t useAsymmFitErrors() const { return useAsymmFitErrors_; }
 
 
    void twoStageFit( Bool_t doTwoStageFit ) { twoStageFit_ = doTwoStageFit; }
 
    Bool_t twoStageFit() const { return twoStageFit_; }
 
 
    virtual void withinAsymErrorCalc( const Bool_t inAsymErrCalc )
    {
        withinAsymErrorCalc_ = inAsymErrCalc;
    }
 
 
    Bool_t withinAsymErrorCalc() const { return withinAsymErrorCalc_; }
 
 
    void setNExpts( UInt_t nExperiments, UInt_t firstExperiment, Bool_t toyExpts );
 
    UInt_t eventsPerExpt() const { return evtsPerExpt_; }
 
    UInt_t nExpt() const { return nExpt_; }
 
    UInt_t firstExpt() const { return firstExpt_; }
 
    UInt_t iExpt() const { return iExpt_; }
 
    Bool_t toyExpts() const { return toyExpts_; }
 
 
    virtual void setParsFromMinuit( Double_t* par, Int_t npar ) = 0;
 
 
    virtual Double_t getTotNegLogLikelihood() = 0;
 
 
    void addConstraint( const TString& formula,
                        const std::vector<TString>& pars,
                        const Double_t mean,
                        const Double_t width );
 
 
    void addFormulaConstraint( const TString& formula,
                               const std::vector<TString>& pars,
                               const Double_t mean,
                               const Double_t width );
 
 
    void addMultiDimConstraint( const std::vector<TString>& pars,
                                const TVectorD& means,
                                const TMatrixD& covMat );
 
  protected:
    LauFitObject();
 
    enum class ConstraintType {
        Formula,    
        MultDim     
    };
 
    // Setup a struct to store information on constrained fit parameters
    struct FormulaConstraint {
        TString formula_;
        std::vector<TString> conPars_;
        Double_t mean_;
        Double_t width_;
        std::unique_ptr<LauFormulaPar> formulaPar_;
    };
 
    // Setup a class to store information on n-dimensional constrained fit parameters
    class MultiDimConstraint {
      public:
        MultiDimConstraint() = default;
 
        MultiDimConstraint( const std::vector<TString>& parNames,
                            const TVectorD& means,
                            const TMatrixD& covMat );
 
        Double_t constraintPenalty() const;
 
        void generateConstraintMeans();
 
        std::vector<TString> conPars_;
        TVectorD trueMeans_;
        TVectorD means_;
        TMatrixD invCovMat_;
        TMatrixD sqrtCovMat_;
        std::vector<LauParameter*> conLauPars_;
    };
 
 
    Bool_t checkRepetition( const std::vector<TString>& names, const ConstraintType conType );
 
 
    void generateConstraintMeans( std::vector<LauAbsRValue*>& conVars );
 
    const std::vector<FormulaConstraint>& formulaConstraints() const { return formulaConstraints_; }
 
    std::vector<FormulaConstraint>& formulaConstraints() { return formulaConstraints_; }
 
    const std::vector<MultiDimConstraint>& multiDimConstraints() const
    {
        return multiDimConstraints_;
    }
 
    std::vector<MultiDimConstraint>& multiDimConstraints() { return multiDimConstraints_; }
 
    const std::set<TString>& formulaConstrainedPars() const { return formulaConstrainedPars_; }
 
    std::set<TString>& formulaConstrainedPars() { return formulaConstrainedPars_; }
 
    const std::set<TString>& multiDimConstrainedPars() const { return multiDimConstrainedPars_; }
 
    std::set<TString>& multiDimConstrainedPars() { return multiDimConstrainedPars_; }
 
    void resetFitCounters();
 
 
    void setCurrentExperiment( const UInt_t curExpt ) { iExpt_ = curExpt; }
 
 
    void startNewFit( const UInt_t nPars, const UInt_t nFreePars );
 
    void eventsPerExpt( UInt_t nEvents ) { evtsPerExpt_ = nEvents; }
 
    Double_t worstLogLike() const { return worstLogLike_; }
 
 
    void worstLogLike( const Double_t newWorstLogLike ) { worstLogLike_ = newWorstLogLike; }
 
 
    void storeFitStatus( const LauAbsFitter::FitStatus& status, const TMatrixD& covMatrix );
 
    UInt_t nTotParams() const { return nParams_; }
 
    UInt_t nFreeParams() const { return nFreeParams_; }
 
    const LauAbsFitter::FitStatus& fitStatus() const { return fitStatus_; }
 
    Double_t nll() const { return fitStatus_.NLL; }
 
    Double_t edm() const { return fitStatus_.EDM; }
 
    Int_t statusCode() const { return fitStatus_.status; }
 
    const TMatrixD& covarianceMatrix() const { return covMatrix_; }
 
    UInt_t numberOKFits() const { return numberOKFits_; }
 
    UInt_t numberBadFits() const { return numberBadFits_; }
 
  private:
    LauFitObject( const LauFitObject& rhs );
 
    LauFitObject& operator=( const LauFitObject& rhs );
 
    std::vector<FormulaConstraint> formulaConstraints_;
 
    std::vector<MultiDimConstraint> multiDimConstraints_;
 
    std::set<TString> formulaConstrainedPars_;
 
    std::set<TString> multiDimConstrainedPars_;
 
    Bool_t twoStageFit_;
 
    Bool_t useAsymmFitErrors_;
 
    UInt_t nParams_;
 
    UInt_t nFreeParams_;
 
    Bool_t withinAsymErrorCalc_;
 
 
    Bool_t toyExpts_;
 
    UInt_t firstExpt_;
 
    UInt_t nExpt_;
 
    UInt_t iExpt_;
 
    UInt_t evtsPerExpt_;
 
    LauAbsFitter::FitStatus fitStatus_;
 
    Double_t worstLogLike_;
 
    TMatrixD covMatrix_;
 
    UInt_t numberOKFits_;
 
    UInt_t numberBadFits_;
 
    ClassDef( LauFitObject, 0 )
};
 
#endif