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 <vector>

#include "TMatrixD.h"
#include "TObject.h"
#include "TString.h"

#include "LauAbsFitter.hh"

class LauFitObject : public TObject {

        public:
                virtual ~LauFitObject() {}


                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 = 0) {
                        nExpt_ = nExperiments;
                        firstExpt_ = firstExperiment;
                }

                UInt_t eventsPerExpt() const {return evtsPerExpt_;}

                UInt_t nExpt() const {return nExpt_;}

                UInt_t firstExpt() const {return firstExpt_;}

                UInt_t iExpt() const {return iExpt_;}


                virtual void setParsFromMinuit(Double_t* par, Int_t npar) = 0;


                virtual Double_t getTotNegLogLikelihood() = 0;


                virtual void addConstraint(const TString& formula, const std::vector<TString>& pars, const Double_t mean, const Double_t width);

        protected:
                LauFitObject();

                // Setup a struct to store information on constrained fit parameters
                struct StoreConstraints {
                        TString formula_;
                        std::vector<TString> conPars_;
                        Double_t mean_;
                        Double_t width_;
                };

                const std::vector<StoreConstraints>& constraintsStore() const {return storeCon_;}

                std::vector<StoreConstraints>& constraintsStore() {return storeCon_;}

                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<StoreConstraints> storeCon_;

                Bool_t twoStageFit_; 

                Bool_t useAsymmFitErrors_; 

                UInt_t nParams_; 

                UInt_t nFreeParams_;

                Bool_t withinAsymErrorCalc_;

                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