BCMTFChannel.h

#ifndef __BCMTFCHANNEL__H
#define __BCMTFCHANNEL__H

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

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

#include <string>
#include <vector>
#include <TH1D.h>

class BCMTFTemplate;
class BCMTFSystematicVariation;
class TH2D;

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

public:

        BCMTFChannel(const char * name);

        ~BCMTFChannel();

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

        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 char * name)
        { fName = name; };

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

        void SetHistUncertaintyBandExpectation(TH2D* hist) {
                fHistUncertaintyBandExpectation = 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 maximumm, int color);

        void PrintTemplates(std::string filename);

        void PrintTemplate(int index, const char * filename);

        void PrintHistUncertaintyBandExpectation(const char* filename);

        void PrintHistUncertaintyBandPoisson(const char* filename, const char* options="COLZ");

        void PrintHistCumulativeUncertaintyBandPoisson(const char* filename);

        void PrintUncertaintyBandPoisson(const char* filename, double minimum, double maximum, int color);

private:

        std::string fName;

        BCMTFTemplate * fData;

        double fRangeYMin;

        double fRangeYMax;

        std::vector<BCMTFTemplate *> fTemplateContainer;

        std::vector<BCMTFSystematicVariation *> fSystematicVariationContainer;

        bool fFlagChannelActive;

        TH2D* fHistUncertaintyBandExpectation;

        TH2D* fHistUncertaintyBandPoisson;

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

#endif