CbmDigiManager.h

Go to the documentation of this file.

/* Copyright (C) 2007-2020 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Volker Friese [committer], Florian Uhlig */
 
#ifndef CBMDIGIMANAGER_H
#define CBMDIGIMANAGER_H 1
 
#include "CbmDefs.h"            // for ECbmModuleId
#include "CbmDigiBranchBase.h"  // for CbmDigiBranchBase
 
#include <FairTask.h>  // for InitStatus
#include <Logger.h>    // for LOG
 
#include <Rtypes.h>      // for THashConsistencyHolder, Cla...
#include <RtypesCore.h>  // for UInt_t, Bool_t, Int_t, kTRUE
 
#include <boost/any.hpp>                  // for any_cast, bad_any_cast (ptr...
#include <boost/exception/exception.hpp>  // for clone_impl, error_info_inje...
 
#include <cassert>  // for assert
#include <gsl/span>
#include <iosfwd>  // for string
#include <map>     // for map, map<>::mapped_type
#include <vector>  // for vector
 
class CbmMatch;
 
class CbmDigiManager {
 
public:
  virtual ~CbmDigiManager();
 
 
  template<class Digi>
  const Digi* Get(Int_t index) const
  {
    assert(fIsInitialised);
    ECbmModuleId system = Digi::GetSystem();
    if (fBranches.find(system) == fBranches.end()) return nullptr;
    try {
      return boost::any_cast<const Digi*>(fBranches[system]->GetDigi(index));
    }
    catch (
      const boost::exception_detail::clone_impl<boost::exception_detail::error_info_injector<boost::bad_any_cast>>&) {
      LOG(fatal) << "Failed boost any_cast in Digimanager::Get for a digi of type " << Digi::GetClassName();
    }  // catch only boost::bad_any_cast which can be triggered by CbmMuchDigi/CbmMuchBeamTimeDigi
    return nullptr;
  }
 
  template<class Digi>
  gsl::span<const Digi> GetArray() const
  {
    assert(fIsInitialised);
    ECbmModuleId system = Digi::GetSystem();
 
    auto branch = fBranches.find(system);
    if (branch == fBranches.end()) {
      LOG(error) << "Failed to find branch for Digi of type " << Digi::GetClassName();
      return {};
    }
 
    boost::any container = branch->second->GetBranchContainer();
    LOG_IF(fatal, container.type() != typeid(const std::vector<Digi>*))
      << "Digis of type " << Digi::GetClassName() << " not stored with std::vector";
 
    return *boost::any_cast<const std::vector<Digi>*>(container);
  }
 
  CbmDigiBranchBase* GetBranch(ECbmModuleId system)
  {
    auto it = fBranches.find(system);
    return (it != fBranches.end() ? it->second : nullptr);
  }
 
 
  const CbmMatch* GetMatch(ECbmModuleId systemId, UInt_t index) const;
 
 
  static Int_t GetNofDigis(ECbmModuleId systemId);
 
 
  InitStatus Init();
 
 
  static CbmDigiManager* Instance()
  {
    if (!fgInstance) fgInstance = new CbmDigiManager();
    return fgInstance;
  }
 
 
  static Bool_t IsPresent(ECbmModuleId systemId);
 
 
  static Bool_t IsMatchPresent(ECbmModuleId systemId);
 
 
  void SetBranchName(ECbmModuleId system, const char* name) { fBranchNames[system] = std::string(name); }
 
 
  //void UseMuchBeamTimeDigi(Bool_t choice = kTRUE) { fUseMuchBeamTimeDigi = choice; }
  void UseMuchBeamTimeDigi(Bool_t /*choice = kTRUE*/) { fUseMuchBeamTimeDigi = kFALSE; }
  void UseMuchBeamTimeDigi() { fUseMuchBeamTimeDigi = kFALSE; }
 
private:
  static std::map<ECbmModuleId, CbmDigiBranchBase*> fBranches;  
  static CbmDigiManager* fgInstance;                            
  static Bool_t fIsInitialised;
  std::map<ECbmModuleId, std::string> fBranchNames {};
  static Bool_t fUseMuchBeamTimeDigi;
 
 
  CbmDigiManager();
 
 
  CbmDigiManager(const CbmDigiManager&) = delete;
 
 
  CbmDigiManager& operator=(const CbmDigiManager&) = delete;
 
 
  template<class Digi>
  void SetBranch();
 
 
  ClassDef(CbmDigiManager, 5);
};
 
 
#endif /* CBMDIGIMANAGER_H */