BATCalculator.h

/*
 * Copyright (C) 2007-2018, the BAT core developer team
 * All rights reserved.
 *
 * Original authors: Gregory Schott and Stefan A. Schmitz with inspiration from
 * Kyle Cranmer, Lorenzo Moneta, Gregory Schott,  and Wouter Verkerke.
 *
 * For the licensing terms see doc/COPYING.
 * For documentation see http://mpp.mpg.de/bat
 */

#ifndef ROOSTATS_BATCalculator
#define ROOSTATS_BATCalculator

#include "BCRooInterface.h"

#include <TH1D.h>
#include <TNamed.h>

#include <RooStats/IntervalCalculator.h>
#include <RooStats/MCMCInterval.h>
#include <RooStats/ModelConfig.h>
#include <RooStats/SimpleInterval.h>

#include <RooAbsData.h>
#include <RooAbsPdf.h>
#include <RooAbsReal.h>
#include <RooArgSet.h>
#include <RooPlot.h>

#include <map>
#include <vector>

namespace RooStats
{

class BATCalculator : public IntervalCalculator, public TNamed
{

public:

    BATCalculator( );

    BATCalculator( RooAbsData& data,
                   RooAbsPdf&   pdf,
                   RooArgSet&   POI,
                   RooAbsPdf&   prior,
                   RooArgSet*   params = 0,
                   bool fillChain = false );

    BATCalculator( RooAbsData&   data,
                   ModelConfig& model,
                   bool fillChain = false);

    virtual ~BATCalculator();

    RooPlot* GetPosteriorPlot1D() const;

    RooAbsPdf* GetPosteriorPdf1D() const;
    RooAbsPdf* GetPosteriorPdf1D(const char* POIname) const;

    virtual SimpleInterval* GetInterval1D() const;
    virtual SimpleInterval* GetInterval1D(const char* POIname) const;

    SimpleInterval* GetShortestInterval1D() const;
    SimpleInterval* GetShortestInterval1D(const char* POIname, bool& checkConnected) const;

    Double_t GetOneSidedUperLim();

    virtual void SetData( RooAbsData& data )
    { fData = &data; ClearAll(); }

    virtual void SetModel(const ModelConfig&) {}

    virtual void SetTestSize( Double_t size )
    { fSize = size; fValidInterval = false; }

    void SetLeftSideTailFraction(Double_t leftSideFraction );

    virtual void SetConfidenceLevel( Double_t cl )
    { SetTestSize(1. - cl); }

    virtual Double_t Size() const
    { return fSize; }
    double GetLeftSideTailFraction()
    { return fLeftSideFraction; }

    virtual Double_t ConfidenceLevel() const
    { return 1. - fSize; }

    void SetBrfPrecision( double precision )
    { fBrfPrecision = precision; }

    double GetBrfPrecision()
    { return fBrfPrecision; }

    void SetnMCMC(int nMCMC)
    { _nMCMC = nMCMC; }

    int  GetnMCMC()
    { return _nMCMC; }

    BCRooInterface* GetBCRooInterface() const
    { return _myRooInterface; }

    RooStats::MarkovChain* GetRooStatsMarkovChain() const
    { return _myRooInterface->GetRooStatsMarkovChain();}

    virtual MCMCInterval* GetInterval() const;

    bool GetConnected()
    { return fConnectedInterval; }

    std::vector<double> GetIntervalBorders1D()
    { return _intervalBorders1D; }

    void SetNumBins(const char* parname, int nbins);

    void SetNumBins(int nbins);

    void CleanCalculatorForNewData()
    { ClearAll(); }

protected:

    void ClearAll() const;

private:
    RooAbsData* fData;
    RooAbsPdf* fPdf;
    const RooArgSet fPOI;
    RooAbsPdf* fPrior;
    const RooArgSet* fparams;
    BCRooInterface* _myRooInterface;
    mutable TH1D* _posteriorTH1D;


    mutable RooAbsPdf* fProductPdf;
    mutable RooAbsReal* fLogLike;
    mutable RooAbsReal* fLikelihood;
    mutable RooAbsReal* fIntegratedLikelihood;
    mutable RooAbsPdf* fPosteriorPdf;
    mutable Double_t fLower;
    mutable Double_t fUpper;
    double fBrfPrecision;
    mutable Bool_t fValidInterval;
    mutable Bool_t fValidMCMCInterval;
    mutable bool fConnectedInterval;

    int _nMCMC; 
    double fSize;  
    double fLeftSideFraction; //
    mutable std::vector<double> _intervalBorders1D;

protected:

    ClassDef(BATCalculator, 1) // BATCalculator class

};
}

#endif