TaskManager.cxx

Go to the documentation of this file.

/* Copyright (C) 2025-2025 Warsaw University of Technology, Warsaw
    SPDX-License-Identifier: GPL-3.0-only
    Authors: Daniel Wielanek [committer] */
#include "TaskManager.h"
 
#include "RootManager.h"
 
#include <RtypesCore.h>
#include <TFile.h>
 
#include <cstdlib>
 
#include <Hal/DataManager.h>
#include <Hal/IOManager.h>
#include <Hal/Package.h>
#include <Hal/Parameter.h>
#include <Hal/Source.h>
#include <Hal/Std.h>
#include <Hal/Task.h>
#include <Hal/TriggerTask.h>
namespace Hal
{
  namespace Fair
  {
    TaskManager::TaskManager() : fManager(nullptr), fProcessedEvents(0) { fManager = new RootManager(); }
 
    InitStatus TaskManager::Init()
    {
      fManager->Init();
      DataManager* mng = DataManager::Instance();
      mng->SetManager(fManager);
      for (auto task : fTriggers) {
        Task::EInitFlag stat = task->Init();
        switch (stat) {
          case Task::EInitFlag::kERROR: {
            fPassiveTriggers.push_back(task);
          } break;
          case Task::EInitFlag::kSUCCESS: {
            fActiveTriggers.push_back(task);
          } break;
          case Task::EInitFlag::kFATAL: {
            exit(0);
            return kFATAL;
          } break;
        }
      }
      for (auto task : fTasks) {
        Task::EInitFlag stat = task->Init();
        switch (stat) {
          case Task::EInitFlag::kERROR: {
            fPassiveTasks.push_back(task);
          } break;
          case Task::EInitFlag::kSUCCESS: {
            fActiveTasks.push_back(task);
          } break;
          case Task::EInitFlag::kFATAL: {
            exit(0);
            return kFATAL;
          } break;
        }
      }
      return kSUCCESS;
    }
 
    void TaskManager::Exec(Option_t* option)
    {
      ++fProcessedEvents;
      for (auto trigger : fActiveTriggers) {
        trigger->Exec(option);
        if (!trigger->IsEventGood()) {
          return;
        }
      }
      for (auto task : fActiveTasks) {
        task->Exec(option);
      }
    }
 
    void TaskManager::Finish()
    {
      auto GoToDir = [](TString name) {
        TDirectory* dir            = (TDirectory*) gFile;
        std::vector<TString> array = Hal::Std::ExplodeString(name, '/');
        for (int i = 0; i < (int) array.size(); i++) {
          TDirectory* newdir = (TDirectory*) dir->FindObject(array[i]);
          if (!newdir) {
            dir->mkdir(array[i]);
          }
          dir->cd(array[i]);
        }
      };
      Package* metadata_new = new Package();
      metadata_new->SetName("RunInfo");
      metadata_new->AddObject(new ParameterString("Software ver", HAL_PHYSICALANALYSYS_VER));
      metadata_new->AddObject(new ParameterString("Date", Hal::Std::GetDate(), 'f'));
      metadata_new->AddObject(new ParameterString("Time", Hal::Std::GetTime(), 'f'));
      metadata_new->AddObject(new ParameterUInt("Processed_events", fProcessedEvents, '+'));
      metadata_new->AddObject(new ParameterString("Input file", DataManager::Instance()->GetSourceName(), 'f'));
      TList* list = new TList();
      list->SetName("Tasks");
      for (auto task : fTasks) {
        TString name  = task->ClassName();
        TString label = "Active";
        for (auto probeTask : fPassiveTasks) {
          if (probeTask == task) label = "Passive";
        }
        list->AddLast(new ParameterString(name, label));
      }
      metadata_new->AddObject(list);
 
      GoToDir("HalInfo");
      TDirectory* dir        = (TDirectory*) gFile;
      TDirectory* metadatata = (TDirectory*) dir->Get("HalInfo");
      if (metadatata->Get("RunInfo")) {
        delete metadata_new;
      }
      else {
        metadata_new->Write("RunInfo");
      }
      gFile->cd();
      for (auto task : fTasks) {
        task->FinishTask();
      }
    }
 
    TaskManager::~TaskManager() {}
  }  // namespace Fair
} /* namespace Hal */