BCMTFChannel.h

#ifndef __BCMTFCHANNEL__H
#define __BCMTFCHANNEL__H

/*
 * Copyright (C) 2007-2018, the BAT core developer team
 * All rights reserved.
 *
 * For the licensing terms see doc/COPYING.
 * For documentation see http://mpp.mpg.de/bat
 */

// ---------------------------------------------------------

#include "../../BAT/BCAux.h"

#include <TH1D.h>

#include <string>
#include <vector>

class BCMTFTemplate;
class BCMTFSystematicVariation;
class TH2D;

// ---------------------------------------------------------
class BCMTFChannel
{

public:

    BCMTFChannel(const std::string& name);

    ~BCMTFChannel();

    const std::string& GetName() const
    { return fName; };

    const std::string& GetSafeName() const
    { return fSafeName; };

    BCMTFTemplate* GetData()
    { return fData; };

    BCMTFTemplate* GetTemplate(int index)
    { return fTemplateContainer.at(index); };

    BCMTFSystematicVariation* GetSystematicVariation(int index)
    { return fSystematicVariationContainer.at(index); };

    bool GetFlagChannelActive()
    { return fFlagChannelActive; };

    TH2D* GetHistUncertaintyBandExpectation()
    { return fHistUncertaintyBandExpectation; };

    TH2D* GetHistUncertaintyBandPoisson()
    { return fHistUncertaintyBandPoisson; };

    double GetRangeYMin()
    { return fRangeYMin; };

    double GetRangeYMax()
    { return fRangeYMax; };

    void SetName(const std::string& name)
    { fName = name; fSafeName = BCAux::SafeName(fName); };

    void SetData(BCMTFTemplate* bctemplate)
    { fData = bctemplate; };

    void SetHistUncertaintyBandExpectation(TH2D* hist);

    void SetHistUncertaintyBandPoisson(TH2D* hist)
    {
        fHistUncertaintyBandPoisson = hist;
    }

    void SetFlagChannelActive(bool flag)
    { fFlagChannelActive = flag; };

    void SetRangeY(double min, double max)
    {
        fRangeYMin = min;
        fRangeYMax = max;
    };

    void AddTemplate(BCMTFTemplate* bctemplate)
    { fTemplateContainer.push_back(bctemplate); };

    void AddSystematicVariation(BCMTFSystematicVariation* variation)
    { fSystematicVariationContainer.push_back(variation); };

    void CalculateHistUncertaintyBandPoisson();

    TH1D* CalculateUncertaintyBandPoisson(double minimum, double maximum, int color);

    void PrintTemplates(const std::string& filename);

    void PrintTemplate(int index, const std::string& filename);

    void PrintHistUncertaintyBandExpectation(const std::string& filename);

    void PrintHistUncertaintyBandPoisson(const std::string& filename, const std::string& options = "COLZ");

    void PrintHistCumulativeUncertaintyBandPoisson(const std::string& filename);

    void PrintUncertaintyBandPoisson(const std::string& filename, double minimum, double maximum, int color);

private:

    std::string fName;

    std::string fSafeName;

    BCMTFTemplate* fData;

    double fRangeYMin;

    double fRangeYMax;

    std::vector<BCMTFTemplate*> fTemplateContainer;

    std::vector<BCMTFSystematicVariation*> fSystematicVariationContainer;

    bool fFlagChannelActive;

    TH2D* fHistUncertaintyBandExpectation;

    TH2D* fHistUncertaintyBandPoisson;

};
// ---------------------------------------------------------

#endif