RawSecMapRootInterface.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <tracking/trackFindingVXD/sectorMapTools/FilterValueDataSet.h>
 
#include <framework/logging/Logger.h>
 
#include <framework/pcore/RootMergeable.h>
#include <framework/datastore/StoreObjPtr.h>
 
#include <framework/pcore/ProcHandler.h>
 
#include <TFile.h>
#include <TTree.h>
#include <string>
 
 
namespace Belle2 {
  class RawSecMapRootInterface {
  protected:
 
    TFile* m_file;
 
    std::string m_name;
 
    StoreObjPtr<RootMergeable<TTree>> m_tree2Hit;
 
    FilterValueDataSet<SecIDPair> m_data2Hit;
 
    StoreObjPtr<RootMergeable<TTree>> m_tree3Hit;
 
    FilterValueDataSet<SecIDTriplet> m_data3Hit;
 
 
  public:
 
 
    RawSecMapRootInterface(const std::string& mapName,  const std::string& tag) :
      m_name(mapName),
      m_tree2Hit((m_name + std::string("2Hit")), DataStore::c_Persistent),
      m_data2Hit({}),
               m_tree3Hit((m_name + std::string("3Hit")), DataStore::c_Persistent),
               m_data3Hit({})
 
    {
      // the "create" option results in the file not being opened if already existing
      std::string fileName = mapName + "_" + tag +  ".root";
      m_file = new TFile((fileName).c_str(), "CREATE");
      if (!m_file->IsOpen()) {
        B2FATAL("File was not opened! File name: " << fileName << " (maybe it already esists!?)");
      }
      m_file->cd();
    }
 
    ~RawSecMapRootInterface() { if (m_file) delete m_file; }
 
 
    RawSecMapRootInterface(const RawSecMapRootInterface& rawSecMapInterFace) = delete;
    RawSecMapRootInterface(RawSecMapRootInterface&& other) :
      m_file(nullptr),
      m_name(std::move(other.m_name)),
      m_tree2Hit(std::move(other.m_tree2Hit)),
      m_data2Hit(std::move(other.m_data2Hit)),
      m_tree3Hit(std::move(other.m_tree3Hit)),
      m_data3Hit(std::move(other.m_data3Hit))
    {
      // the new object takes ownership of the file
      m_file = other.m_file;
      other.m_file = nullptr;
    }
 
    RawSecMapRootInterface& operator = (const RawSecMapRootInterface& rawSecMapInterFace) = delete;
 
 
    void initialize2Hit(std::vector<std::string> filterNames)
    {
      B2DEBUG(20, "RawSecMapRootInterface::initialize2Hit: start - got " << filterNames.size() << " filters");
      B2DEBUG(20, "and root file got size of: " << m_file->GetSize());
      m_file->cd();
 
      // preparing StoreObjPtr:
      bool registered = m_tree2Hit.registerInDataStore((m_name + std::string("2Hit")), DataStore::c_ErrorIfAlreadyRegistered);
      bool constructed = m_tree2Hit.construct((m_name + std::string("2Hit")).c_str(), "Raw data of two-hit-combinations for a sectorMap");
      B2DEBUG(20, "RawSecMapRootInterface::initialize2Hit: isRegistered/isConstructed: " << registered << "/" << constructed);
 
      // preparing data-mask for 2-hit-combinations:
      m_data2Hit = FilterValueDataSet<SecIDPair>(filterNames);
 
      m_tree2Hit->get().Branch("expNo", &(m_data2Hit.expNo));
      m_tree2Hit->get().Branch("runNo", &(m_data2Hit.runNo));
      m_tree2Hit->get().Branch("evtNo", &(m_data2Hit.evtNo));
      m_tree2Hit->get().Branch("trackNo", &(m_data2Hit.trackNo));
      m_tree2Hit->get().Branch("pdg", &(m_data2Hit.pdg));
      m_tree2Hit->get().Branch("outerSecID", &(m_data2Hit.secIDs.outer));
      m_tree2Hit->get().Branch("innerSecID", &(m_data2Hit.secIDs.inner));
 
      B2DEBUG(20, "RawSecMapRootInterface::initialize2Hit: adding " << filterNames.size() << " filters as branches to ttree ");
      for (auto& name : filterNames) {
        double* valuePtr = m_data2Hit.getValuePtr(name);
        if (valuePtr != nullptr) {
          B2DEBUG(20, "RawSecMapRootInterface::initialize2Hit: adding now branch with name " << name);
          m_tree2Hit->get().Branch(name.c_str(), valuePtr);
        } else {
          B2ERROR("RawSecMapRootInterface::initialize2Hit: filterName " << name <<
                  " not known! this is unintended behavior - skipping filter");
        }
 
      }
      B2DEBUG(20, "RawSecMapRootInterface::initialize2Hit: nBranches/nEntries: " << m_tree2Hit->get().GetNbranches() << "/" <<
              m_tree2Hit->get().GetEntries());
    }
 
 
 
    void initialize3Hit(std::vector<std::string> filterNames)
    {
      B2DEBUG(20, "RawSecMapRootInterface::initialize3Hit: start");
      m_file->cd();
 
      // preparing StoreObjPtr:
      bool registered = m_tree3Hit.registerInDataStore((m_name + std::string("3Hit")), DataStore::c_ErrorIfAlreadyRegistered);
      bool constructed = m_tree3Hit.construct((m_name + std::string("3Hit")).c_str(),
                                              "Raw data of three-hit-combinations for a sectorMap");
      B2DEBUG(20, "RawSecMapRootInterface::initialize3Hit: isRegistered/isConstructed: " << registered << "/" << constructed);
 
      // preparing data-mask for 2-hit-combinations:
      m_data3Hit = FilterValueDataSet<SecIDTriplet>(filterNames);
 
      m_tree3Hit->get().Branch("expNo", &(m_data3Hit.expNo));
      m_tree3Hit->get().Branch("runNo", &(m_data3Hit.runNo));
      m_tree3Hit->get().Branch("evtNo", &(m_data3Hit.evtNo));
      m_tree3Hit->get().Branch("trackNo", &(m_data3Hit.trackNo));
      m_tree3Hit->get().Branch("pdg", &(m_data3Hit.pdg));
      m_tree3Hit->get().Branch("outerSecID", &(m_data3Hit.secIDs.outer));
      m_tree3Hit->get().Branch("centerSecID", &(m_data3Hit.secIDs.center));
      m_tree3Hit->get().Branch("innerSecID", &(m_data3Hit.secIDs.inner));
 
      B2DEBUG(20, "RawSecMapRootInterface::initialize3Hit: adding " << filterNames.size() << " filters as branches to ttree ");
      for (auto& name : filterNames) {
        double* valuePtr = m_data3Hit.getValuePtr(name);
        if (valuePtr != nullptr) {
          B2DEBUG(20, "RawSecMapRootInterface::initialize3Hit: adding now branch with name " << name);
          m_tree3Hit->get().Branch(name.c_str(), valuePtr);
        } else {
          B2ERROR("RawSecMapRootInterface::initialize3Hit: filterName " << name <<
                  " not known! this is unintended behavior - skipping filter");
        }
 
      }
      B2DEBUG(20, "RawSecMapRootInterface::initialize3Hit: nBranches/nEntries: " << m_tree3Hit->get().GetNbranches() << "/" <<
              m_tree3Hit->get().GetEntries());
    }
 
    FilterValueDataSet<SecIDPair>& get2HitDataSet() { return m_data2Hit; }
 
 
    FilterValueDataSet<SecIDTriplet>& get3HitDataSet() { return m_data3Hit; }
 
 
 
    void fill2Hit()
    {
      if (!m_data2Hit.isValid()) {
        B2ERROR("RawSecMapRootInterface::fill2Hit: attempt to fill invalid data in the tree! -> unintended behavior, data will not be filled.");
        m_data2Hit.reset();
        return;
      }
      m_tree2Hit->get().Fill();
      m_data2Hit.reset();
    }
 
 
    void fill3Hit()
    {
      if (!m_data3Hit.isValid()) {
        B2ERROR("RawSecMapRootInterface::fill3Hit: attempt to fill invalid data in the tree! -> unintended behavior, data will not be filled.");
        m_data3Hit.reset();
        return;
      }
      m_tree3Hit->get().Fill();
      m_data3Hit.reset();
    }
 
 
    void write()
    {
      B2DEBUG(20, "RawSecMapRootInterface::write: start");
      m_file->cd();
 
      if (!ProcHandler::parallelProcessingUsed() or ProcHandler::isOutputProcess()) {
        //use TFile you created in initialize()
        m_tree2Hit->write(m_file);
        m_tree3Hit->write(m_file);
 
      }
    }
 
  };
}