CutFlowCounter.h

Go to the documentation of this file.

//***************************************************************************************
//***************************************************************************************
 
#pragma once
 
#include "NAGASH/Result.h"
 
namespace NAGASH
{
    class CutFlowCounter : public Result
    {
    private:
        std::vector<double> SumE;
        std::vector<double> SumW;
        std::map<std::string, uint64_t> CutPointNames;
        std::vector<std::string> CutPointNamesVector;
 
    public:
        CutFlowCounter(std::shared_ptr<MSGTool> msg, std::shared_ptr<ConfigTool> config, const TString &name, const TString &fname = "")
            : Result(msg, config, name, fname) {}
 
        void BookCutPoint(const std::string &name)
        {
            CutPointNames.emplace(std::pair<std::string, uint64_t>(name, SumE.size()));
            SumE.emplace_back(0);
            SumW.emplace_back(0);
            CutPointNamesVector.emplace_back(name);
        }
 
        void Record(uint64_t point, double w = 1)
        {
            if (point < SumE.size())
            {
                SumE[point] += 1;
                SumW[point] += w;
            }
            else
            {
                auto guard = MSGUser()->StartTitleWithGuard("CutFlowCounter::Record");
                MSGUser()->MSG_WARNING("Cut point ", point, " does not exist!");
            }
        }
 
        void Record(const std::string &point, double w = 1)
        {
            if (auto result = CutPointNames.find(point); result != CutPointNames.end())
            {
                SumE[result->second] += 1;
                SumW[result->second] += w;
            }
            else
            {
                auto guard = MSGUser()->StartTitleWithGuard("CutFlowCounter::Record");
                MSGUser()->MSG_WARNING("Cut point ", point, " does not exist!");
            }
        }
 
        void Combine(std::shared_ptr<Result> result)
        {
            auto subCounter = std::dynamic_pointer_cast<std::remove_pointer<decltype(this)>::type>(result);
            auto guard = MSGUser()->StartTitleWithGuard("CutFlowCounter::Combine");
            if (subCounter != nullptr)
            {
                if (CutPointNames != subCounter->CutPointNames)
                {
                    MSGUser()->MSG_WARNING("Two cut flow counter are note the same (", GetResultName(), " and ", subCounter->GetResultName(), ")");
                    return;
                }
 
                for (size_t i = 0; i < SumE.size(); ++i)
                {
                    SumE[i] += subCounter->SumE[i];
                    SumW[i] += subCounter->SumW[i];
                }
            }
        }
 
        double GetEntries(uint32_t point)
        {
            if (point < SumE.size())
            {
                return SumE[point];
            }
            else
            {
                auto guard = MSGUser()->StartTitleWithGuard("CutFlowCounter::Record");
                MSGUser()->MSG_WARNING("Cut point ", point, " does not exist!");
            }
        }
 
        double GetEntries(const std::string &point)
        {
            if (auto result = CutPointNames.find(point); result != CutPointNames.end())
            {
                return SumE[result->second];
            }
            else
            {
                auto guard = MSGUser()->StartTitleWithGuard("CutFlowCounter::Record");
                MSGUser()->MSG_WARNING("Cut point ", point, " does not exist!");
            }
        }
 
        double GetSumW(uint32_t point)
        {
            if (point < SumW.size())
            {
                return SumW[point];
            }
            else
            {
                auto guard = MSGUser()->StartTitleWithGuard("CutFlowCounter::Record");
                MSGUser()->MSG_WARNING("Cut point ", point, " does not exist!");
            }
        }
 
        double GetSumW(const std::string &point)
        {
            if (auto result = CutPointNames.find(point); result != CutPointNames.end())
            {
                return SumW[result->second];
            }
            else
            {
                auto guard = MSGUser()->StartTitleWithGuard("CutFlowCounter::Record");
                MSGUser()->MSG_WARNING("Cut point ", point, " does not exist!");
            }
        }
 
        void PrintSummary()
        {
            auto guard = MSGUser()->StartTitleWithGuard("CutFlowCounter::PrintSummary");
            MSGUser()->MSG_INFO("Summary of cut flow counter ", GetResultName());
            for (size_t i = 0; i < SumE.size(); ++i)
                MSGUser()->MSG_INFO("Cut point ", CutPointNamesVector[i], "  Entries : ", SumE[i], "  SumW : ", SumW[i], "  Eff : ", SumW[i] / SumW[0], " Relative Eff : ", i == 0 ? 1 : SumW[i] / SumW[i - 1]);
        }
    };
 
}