CbmDigiBranch.h

Go to the documentation of this file.

 
#include <vector>
 
#include <FairLogger.h>
#include <FairRootManager.h>
#include <TClonesArray.h>
 
#include "CbmDefs.h"
#include "CbmDigiBranchBase.h"
#include "CbmMatch.h"
 
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_t 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 kTRUE;
    return kFALSE;
  }
  // -----------------------------------------------------------------------
 
 
  // -----------------------------------------------------------------------
  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(UInt_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(UInt_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_t HasMatches() {
    if (fMatchVector || fMatchArray) return kTRUE;
    return kFALSE;
  }
  // -----------------------------------------------------------------------
 
 
  // -----------------------------------------------------------------------
  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();
  }
  // -----------------------------------------------------------------------
 
 
private:
  const std::vector<Digi>* fDigiVector;       
  const std::vector<CbmMatch>* fMatchVector;  
  TClonesArray* fDigiArray;                   
  TClonesArray* fMatchArray;                  
};