LoopEvent.h

Go to the documentation of this file.

//***************************************************************************************
//***************************************************************************************
 
#pragma once
 
#include "NAGASH/Global.h"
#include "NAGASH/ConfigTool.h"
#include "NAGASH/ResultGroup.h"
#include "NAGASH/MSGTool.h"
#include "NAGASH/Toolkit.h"
#include "NAGASH/Timer.h"
#include "NAGASH/EventVector.h"
#include "NAGASH/Job.h"
 
namespace NAGASH
{
    class LoopEvent : public Job
    {
    public:
        LoopEvent(const ConfigTool &c) : Job(c) {}
        virtual ~LoopEvent();
 
        virtual StatusCode InitializeData() = 0;
 
        virtual StatusCode InitializeUser() = 0; 
        virtual StatusCode Execute() = 0;        
        virtual StatusCode Finalize() = 0;       
        StatusCode OpenRootFile(const TString &);
        StatusCode Run();
        void SetEventVector(std::shared_ptr<EventVector> ev);
 
        template <typename LE>
        static StatusCode Process(const ConfigTool &, std::shared_ptr<ResultGroup>, std::shared_ptr<ResultGroup>, const TString &);
 
    protected:
        TTree *&RootTreeUser();
        TFile *RootFileUser();
        int CurrentEntry();
        const TString &InputRootFileName();
        std::shared_ptr<EventVector> EventVectorUser();
 
    private:
        TTree *fChain = nullptr;
        int NEventsToLoop = 0;
        TFile *infile = nullptr;
        std::shared_ptr<EventVector> eventvector;
        TString inputrootfilename;
        int entry = -1;
    };
 
    inline TTree *&LoopEvent::RootTreeUser() { return fChain; }
    inline TFile *LoopEvent::RootFileUser() { return infile; }
    inline int LoopEvent::CurrentEntry() { return entry; }
    inline void LoopEvent::SetEventVector(std::shared_ptr<EventVector> ev) { eventvector = ev; }
    inline std::shared_ptr<EventVector> LoopEvent::EventVectorUser() { return eventvector; }
    inline const TString &LoopEvent::InputRootFileName() { return inputrootfilename; }
 
    template <typename LE>
    StatusCode LoopEvent::Process(const ConfigTool &config_child, std::shared_ptr<ResultGroup> result, std::shared_ptr<ResultGroup> wholeresult, const TString &inputfilename)
    {
        static_assert(!std::is_pointer<LE>::value, "LoopEvent::Process : type can not be a pointer");
        static_assert(std::is_base_of<LoopEvent, LE>::value, "LoopEvent::Process : Input type must be or be inherited from LoopEvent class");
 
        Job::DefaultMutex.lock();
        auto childLE = std::make_shared<LE>(config_child);
        if (childLE->OpenRootFile(inputfilename) == StatusCode::FAILURE)
        {
            childLE.reset();
            Job::DefaultMutex.unlock();
            return StatusCode::FAILURE;
        }
        auto msg_child = childLE->MSGUser();
        TString threadsuffix;
        if (childLE->JobNumber() >= 0)
            threadsuffix.Form("(Job %d)", childLE->JobNumber());
 
        msg_child->StartTitle("LE::InitializeData" + threadsuffix);
        if (childLE->InitializeData() == StatusCode::FAILURE)
        {
            msg_child->EndTitle();
            childLE.reset();
            Job::DefaultMutex.unlock();
            return StatusCode::FAILURE;
        }
        msg_child->EndTitle();
 
        msg_child->StartTitle("LE::InitializeUser" + threadsuffix);
        if (childLE->InitializeUser() == StatusCode::FAILURE)
        {
            msg_child->EndTitle();
            childLE.reset();
            Job::DefaultMutex.unlock();
            return StatusCode::FAILURE;
        }
        msg_child->EndTitle();
 
        Job::DefaultMutex.unlock();
 
        msg_child->StartTitle("LE::Run" + threadsuffix);
        if (childLE->Run() == StatusCode::FAILURE)
        {
            msg_child->EndTitle();
            Job::DefaultMutex.lock();
            childLE.reset();
            Job::DefaultMutex.unlock();
            return StatusCode::FAILURE;
        }
        msg_child->EndTitle();
 
        Job::DefaultMutex.lock();
        // Add Child Result to Mother
        msg_child->StartTitle("LE::Finalize" + threadsuffix);
        if (childLE->Finalize() == StatusCode::FAILURE)
        {
            msg_child->EndTitle();
            childLE.reset();
            Job::DefaultMutex.unlock();
            return StatusCode::FAILURE;
        }
        msg_child->EndTitle();
        wholeresult->Merge(childLE->ResultGroupUser());
        childLE.reset();
        Job::DefaultMutex.unlock();
 
        return StatusCode::SUCCESS;
    }
 
} // namespace NAGASH