CbmDigiBranch.h

Go to the documentation of this file.

/* Copyright (C) 2019-2020 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Volker Friese [committer] */
 
#include "CbmDefs.h"
#include "CbmDigiBranchBase.h"
#include "CbmMatch.h"
 
#include <FairRootManager.h>
#include <Logger.h>
 
#include <TClonesArray.h>
 
#include <vector>
 
template<class Digi>
class CbmDigiBranch : public CbmDigiBranchBase {
 
public:
  // -----------------------------------------------------------------------
  CbmDigiBranch(const char* name = "unknown")
    : CbmDigiBranchBase(name)
    , fDigiVector(nullptr)
    , fMatchVector(nullptr)
    , fDigiArray(nullptr)
    , fMatchArray(nullptr)
  {
  }
  // -----------------------------------------------------------------------
 
 
  // -----------------------------------------------------------------------
  virtual ~CbmDigiBranch() {}
  // -----------------------------------------------------------------------
 
 
  // -----------------------------------------------------------------------
  virtual bool ConnectToTree()
  {
 
    FairRootManager* frm = FairRootManager::Instance();
 
    // Try to find a vector branch for the digi
    fDigiVector = frm->InitObjectAs<std::vector<Digi> const*>(fName.Data());
 
    // Try to find a TClonesArray branch for the digi
    if (!fDigiVector) { fDigiArray = dynamic_cast<TClonesArray*>(frm->GetObject(fName)); }
 
    // Try to find a vector branch for the match
    TString mBranch = fName + "Match";
    fMatchVector    = frm->InitObjectAs<std::vector<CbmMatch> const*>(mBranch.Data());
 
    // Try to find a TClonesArray branch for the match
    if (!fMatchVector) { fMatchArray = dynamic_cast<TClonesArray*>(frm->GetObject(mBranch.Data())); }
 
    if (fDigiVector || fDigiArray) return true;
    return false;
  }
  // -----------------------------------------------------------------------
 
 
  // -----------------------------------------------------------------------
  virtual std::size_t GetNofDigis() const
  {
    std::size_t nDigis = 0;
    if (fDigiVector) nDigis = fDigiVector->size();
    else if (fDigiArray) {
      assert(fDigiArray->GetEntriesFast() >= 0);
      nDigis = fDigiArray->GetEntriesFast();
    }
    return nDigis;
  }
  // -----------------------------------------------------------------------
 
 
  // -----------------------------------------------------------------------
  virtual boost::any GetDigi(uint32_t index)
  {
    const Digi* digi = nullptr;
    if (index < GetNofDigis()) {
      if (fDigiVector) digi = &((*fDigiVector)[index]);
      else if (fDigiArray)
        digi = dynamic_cast<const Digi*>(fDigiArray->At(index));
    }
    return digi;
  }
  // -----------------------------------------------------------------------
 
 
  // -----------------------------------------------------------------------
  virtual const CbmMatch* GetDigiMatch(uint32_t index)
  {
    const CbmMatch* match = nullptr;
    if (index < GetNofDigis()) {
      if (fMatchVector) match = &((*fMatchVector)[index]);
      else if (fMatchArray)
        match = static_cast<const CbmMatch*>(fMatchArray->At(index));
    }
    return match;
  }
  // -----------------------------------------------------------------------
 
 
  // -----------------------------------------------------------------------
  virtual bool HasMatches()
  {
    if (fMatchVector || fMatchArray) return true;
    return false;
  }
  // -----------------------------------------------------------------------
 
 
  // -----------------------------------------------------------------------
  virtual std::string ToString() const
  {
    std::stringstream ss;
    ss << "Branch " << fName << " (";
    if (fDigiVector) ss << "vector";
    else if (fDigiArray)
      ss << "TClonesArray";
    else
      ss << "not connected";
    ss << "), match branch " << fName + "Match (";
    if (fMatchVector) ss << "vector";
    else if (fMatchArray)
      ss << "TClonesArray";
    else
      ss << "not connected";
    ss << ")";
    return ss.str();
  }
  // -----------------------------------------------------------------------
 
  // -----------------------------------------------------------------------
  virtual boost::any GetBranchContainer() const
  {
    if (fDigiVector) return fDigiVector;
    else if (fDigiArray)
      return fDigiArray;
    return nullptr;
  }
  // -----------------------------------------------------------------------
 
 
private:
  const std::vector<Digi>* fDigiVector;       
  const std::vector<CbmMatch>* fMatchVector;  
  TClonesArray* fDigiArray;                   
  TClonesArray* fMatchArray;                  
};