AgataEventContainer.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004-2006 by Olivier Stezowski & Christian Finck        *
 *   stezow(AT)ipnl.in2p3.fr, cfinck(AT)ires.in2p3.fr                      *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   FreAgataEventContainere Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifndef ROOT_TBranch
#include "TBranch.h"
#endif

#ifndef Gw_AgataEventContainer
#include "AgataEventContainer.h"
#endif

using namespace Gw;

//
ClassImp(AgataEventContainer)
ClassImp(TrackHit)
ClassImp(StdHit)

const   Int_t AgataEventContainer::fgkMaxNofTypeName = 4;
      TString AgataEventContainer::fgTypeName[fgkMaxNofTypeName] = {"Agata", "HeavyIons", "LightCP", "Neutron"};
const TString AgataEventContainer::fgkTypeNameExt[]              = {"_Tracks", "_Hits"};

//__________________________________________________________
AgataEventContainer::AgataEventContainer() 
  : BaseEventContainer(),
        fTrackList(new TClonesArray("Gw::TrackHit")),
        fHitList(new TClonesArray("Gw::StdHit")),
        fNofBracnhes(0)
{ 
  // default constructor
  fLog.GetProcessName() = "AgataEventContainer";

  // register at least Agata
  RegisterBranch();
}

//__________________________________________________________
AgataEventContainer::~AgataEventContainer()
{
  // default destructor
  for (Int_t i = 0; i < fNofBracnhes; ++i) {
        delete fCurrentTrackList[i];
        delete fCurrentHitList[i];
  }
  delete fHitList;
  delete fTrackList;
}

//__________________________________________________________
const Char_t* AgataEventContainer::RegisterBranch(Option_t* type)
{
  if (++fNofBracnhes >= fgkMaxNofTypeName) {
        fLog.SetProcessMethod("RegisterBranch(Option_t* )");
        fLog << error << "Too many branches registered" << dolog;
        return "";
  }
  
  TString name(type);
  if (!name.IsNull())
        fgTypeName[fNofBracnhes-1] = type;
  
  name = fgTypeName[fNofBracnhes-1].Data() + fgkTypeNameExt[0];
  fCurrentTrackList[fNofBracnhes-1] = new TClonesArray("Gw::TrackHit");
  fEventTree->Branch(name.Data(), &fCurrentTrackList[fNofBracnhes-1]);
  
  name = fgTypeName[fNofBracnhes-1].Data() + fgkTypeNameExt[1];
  fCurrentHitList[fNofBracnhes-1] = new TClonesArray("Gw::StdHit");
  fEventTree->Branch(name.Data(), &fCurrentHitList[fNofBracnhes-1]);
  
  return fgTypeName[fNofBracnhes-1].Data();
}

//__________________________________________________________
void AgataEventContainer::ClearEvents()
{
  for (Int_t i = 0; i < fNofBracnhes; ++i) {
        fCurrentTrackList[i]->Clear();
        fCurrentHitList[i]->Clear();
  }
  fEventTree->Clear();
}

//__________________________________________________________
void AgataEventContainer::FillHits(Option_t* type) 
{ 
  Int_t idx = GetIndex(type);
  if (idx == -1) {
        fLog.SetProcessMethod("FillHits(Option_t* )");
        fLog << error << "Unkown type" << dolog;
        return;
  }
  
  TString name = GetHitBranchName(type);
  TBranch* b = fEventTree->GetBranch(name.Data());

  b->Fill();
  if (b->GetEntries() > fNofEvents)
        fNofEvents = b->GetEntries();
  
  for (Int_t i = 0; i < fNofBracnhes; ++i) {
        fCurrentHitList[i]->Delete();
  }
}

//__________________________________________________________
void AgataEventContainer::FillTracks(Option_t* type) 
{ 
  Int_t idx = GetIndex(type);
  if (idx == -1) {
          fLog.SetProcessMethod("FillTracks(Option_t* )");
        fLog << error << "Unkown type" << dolog;
        return;
  }
  
  TString name = GetTrackBranchName(type);
  TBranch* b = fEventTree->GetBranch(name.Data());
  
  b->Fill(); 
  if (b->GetEntries() > fNofEvents)
        fNofEvents = b->GetEntries();
  
  for (Int_t i = 0; i < fNofBracnhes; ++i) {
        fCurrentTrackList[i]->Delete();
  }
}


//__________________________________________________________
TrackHit* AgataEventContainer::NewTrackHit(Option_t* type)
{  
  fLog.SetProcessMethod("NewTrackHit(Option_t* )");
  
  Int_t idx = GetIndex(type);
  if (idx == -1) {
        fLog << error << "Unkown type" << dolog;
        return 0x0;
  }
  
  if (fCurrentTrackList[idx] == 0x0) {
    fLog << error << "No current track list available" << dolog;
    return 0x0;
  }
  
  TClonesArray &hitArray = *fCurrentTrackList[idx];
  TrackHit* hit =  new(hitArray[hitArray.GetEntriesFast()]) TrackHit();
  
  fLog << dolog;
  return hit;
}

//__________________________________________________________
StdHit* AgataEventContainer::NewHit(Option_t* type)
{
  fLog.SetProcessMethod("NewHit(Option_t* )");

  Int_t idx = GetIndex(type);
  if (idx == -1) {
        fLog << error << "Unkown type" << dolog;
        return 0x0;
  }
  
  if (fCurrentHitList[idx] == 0x0) {
    fLog << error << "No current hit list available" << dolog;
    return 0x0;
  }
  
  TClonesArray &hitArray = *fCurrentHitList[idx];
  StdHit* hit = new(hitArray[hitArray.GetEntriesFast()]) StdHit();
        
  fLog << dolog;
  return hit;
}

//__________________________________________________________
Int_t AgataEventContainer::GetIndex(Option_t* type) const
{
  TString tmp(type);
  
  for (Int_t i = 0; i < fNofBracnhes; ++i) {
        if (tmp.CompareTo(fgTypeName[i]) == 0)
          return i;
  }
  
  return -1;
}

//__________________________________________________________
TString AgataEventContainer::GetTrackBranchName(Option_t* type) const
{
  Int_t idx = GetIndex(type);
  if (idx == -1) {
        fLog.SetProcessMethod("GetTrackBranchName(Option_t*)");
        fLog << error << "Unkown type" << dolog;
        return TString("");
  }
  
  TString name = fgTypeName[idx].Data() + fgkTypeNameExt[0];

  return TString(name);
}

//__________________________________________________________
TString AgataEventContainer::GetHitBranchName(Option_t* type) const
{
  Int_t idx = GetIndex(type);
  if (idx == -1) {
        fLog.SetProcessMethod("GetHitBranchName(Option_t*)");
        fLog << error << "Unkown type" << dolog;
        return TString("");
  }
  
  TString name = fgTypeName[idx].Data() + fgkTypeNameExt[1];
  
  return TString(name);
}

//__________________________________________________________
TClonesArray* AgataEventContainer::GetTrackList(Int_t ievent, Option_t* type, Bool_t warn)
{
  TString name = GetTrackBranchName(type);
  if (name.IsNull())
        return 0x0;
  
  TBranch* b = fEventTree->GetBranch(name.Data());
  
  if (ievent >= b->GetEntries()) {
        if (warn) {
          fLog.SetProcessMethod("GetTrackList(Int_t, Option_t* )");
          fLog << "index too large" << dolog;
        }
    return 0x0;
  }

  fTrackList->Delete();
  
  b->SetAddress(&fTrackList);
  b->GetEntry(ievent);
  return fTrackList;
}

//__________________________________________________________
TClonesArray* AgataEventContainer::GetHitList(Int_t ievent, Option_t* type, Bool_t warn)
{
  TString name = GetHitBranchName(type);
  if (name.IsNull())
        return 0x0;
  
  TBranch* b = fEventTree->GetBranch(name.Data());
  
  if (ievent >= b->GetEntries()) {
        if (warn) {
          fLog.SetProcessMethod("GetHitList(Int_t, Option_t* )");
          fLog << "index too large" << dolog;
        }
    return 0x0;
  }
    
  fHitList->Delete();
  
  b->SetAddress(&fHitList);
  b->GetEntry(ievent);

  return fHitList;
}


//_________________________________________________________

//__________________________________________________________
TrackHit::TrackHit() 
  : TObject(),
        fTrackList(new TClonesArray("Gw::StdHit"))
{
  fTrackList->SetOwner(true); 
}

//__________________________________________________________
TrackHit::~TrackHit()
{
  delete fTrackList;
}

//__________________________________________________________
Int_t TrackHit::GetNbHits() const
{
  return fTrackList->GetEntries();
}

//__________________________________________________________
StdHit* TrackHit::NewHit()
{
  TClonesArray &hitArray = *fTrackList;
  StdHit* hit = new(hitArray[hitArray.GetEntriesFast()]) StdHit();
  
  return hit;
}

//__________________________________________________________
StdHit* TrackHit::GetHit(Int_t i) const
{
  if (i >= fTrackList->GetEntries() && i >= 0)
    return 0x0;
  
  return (StdHit*)fTrackList->At(i);
  
}