TDigiEvent.cxx

Go to the documentation of this file.

#include "RootEventData/TDigiEvent.h"
#include "TCollection.h" // Declares TIter
#include <iostream>
 
ClassImp( TDigiEvent );
;
 
// Allocate the TObjArray just once
TObjArray* TDigiEvent::s_staticMdcDigiCol  = 0;
TObjArray* TDigiEvent::s_staticEmcDigiCol  = 0;
TObjArray* TDigiEvent::s_staticTofDigiCol  = 0;
TObjArray* TDigiEvent::s_staticMucDigiCol  = 0;
TObjArray* TDigiEvent::s_staticLumiDigiCol = 0;
 
//***************************************************************
TDigiEvent::TDigiEvent() {
  if ( !s_staticMdcDigiCol ) { s_staticMdcDigiCol = new TObjArray(); }
  m_mdcDigiCol = s_staticMdcDigiCol;
 
  if ( !s_staticEmcDigiCol ) { s_staticEmcDigiCol = new TObjArray(); }
  m_emcDigiCol = s_staticEmcDigiCol;
 
  if ( !s_staticTofDigiCol ) { s_staticTofDigiCol = new TObjArray(); }
  m_tofDigiCol = s_staticTofDigiCol;
 
  if ( !s_staticMucDigiCol ) { s_staticMucDigiCol = new TObjArray(); }
  m_mucDigiCol = s_staticMucDigiCol;
 
  if ( !s_staticLumiDigiCol ) { s_staticLumiDigiCol = new TObjArray(); }
  m_lumiDigiCol = s_staticLumiDigiCol;
 
  Clear();
}
 
//*****************************************************************
TDigiEvent::~TDigiEvent() {
 
  if ( m_mdcDigiCol == s_staticMdcDigiCol ) s_staticMdcDigiCol = 0;
  m_mdcDigiCol->Delete();
  delete m_mdcDigiCol;
  m_mdcDigiCol = 0;
 
  if ( m_emcDigiCol == s_staticEmcDigiCol ) s_staticEmcDigiCol = 0;
  m_emcDigiCol->Delete();
  delete m_emcDigiCol;
  m_emcDigiCol = 0;
 
  if ( m_tofDigiCol == s_staticTofDigiCol ) s_staticTofDigiCol = 0;
  m_tofDigiCol->Delete();
  delete m_tofDigiCol;
  m_tofDigiCol = 0;
 
  if ( m_mucDigiCol == s_staticMucDigiCol ) s_staticMucDigiCol = 0;
  m_mucDigiCol->Delete();
  delete m_mucDigiCol;
  m_mucDigiCol = 0;
 
  if ( m_lumiDigiCol == s_staticLumiDigiCol ) s_staticLumiDigiCol = 0;
  m_lumiDigiCol->Delete();
  delete m_lumiDigiCol;
  m_lumiDigiCol = 0;
}
 
//*****************************************************************
void TDigiEvent::initialize( Bool_t fromMc ) { m_fromMc = fromMc; }
 
//*****************************************************************
void TDigiEvent::Clear( Option_t* option ) {
  /*
    const Int_t nd = 20000;
    static Int_t limit = 100;
    static Int_t ind=0;
    static TMdcDigi* keep[nd];
 
 
    Int_t n = m_mdcDigiCol->GetEntries();
    if (n>limit) {
      limit=n+10;
      if (limit > nd)
        std::cout << "!!!Warning: limit for TMdcDigi is greater than " << nd << std::endl;
      for (Int_t j=0;j<ind;j++) delete keep[j];
      ind = 0;
    }
    for (Int_t i=0;i<n;i++) keep[ind+i] = (TMdcDigi*)m_mdcDigiCol->At(i);
    ind += n;
    if (ind > nd-limit) {
      for (Int_t j=0;j<ind;j++) delete keep[j];
      ind = 0;
    }
    m_mdcDigiCol->Clear();
*/
}
 
//*****************************************************************************
void TDigiEvent::Print( Option_t* option ) const {
  TObject::Print( option );
  std::cout.precision( 2 );
  if ( m_mdcDigiCol )
    std::cout << "Number of TMdcDigis " << m_mdcDigiCol->GetEntries() << std::endl;
  else std::cout << "Number of TMdcDigis 0" << std::endl;
}
 
/// Mdc
void TDigiEvent::addMdcDigi( TMdcDigi* digi ) { m_mdcDigiCol->Add( digi ); }
 
const TMdcDigi* TDigiEvent::getMdcDigi( Int_t i ) const {
  if ( Int_t( i ) >= m_mdcDigiCol->GetEntries() ) return 0;
  return (TMdcDigi*)m_mdcDigiCol->At( i );
}
/// Emc
void TDigiEvent::addEmcDigi( TEmcDigi* digi ) { m_emcDigiCol->Add( digi ); }
 
const TEmcDigi* TDigiEvent::getEmcDigi( Int_t i ) const {
  if ( Int_t( i ) >= m_emcDigiCol->GetEntries() ) return 0;
  return (TEmcDigi*)m_emcDigiCol->At( i );
}
 
/// Tof
void TDigiEvent::addTofDigi( TTofDigi* digi ) { m_tofDigiCol->Add( digi ); }
 
const TTofDigi* TDigiEvent::getTofDigi( Int_t i ) const {
  if ( Int_t( i ) >= m_tofDigiCol->GetEntries() ) return 0;
  return (TTofDigi*)m_tofDigiCol->At( i );
}
 
/// Muc
void TDigiEvent::addMucDigi( TMucDigi* digi ) { m_mucDigiCol->Add( digi ); }
 
const TMucDigi* TDigiEvent::getMucDigi( Int_t i ) const {
  if ( Int_t( i ) >= m_mucDigiCol->GetEntries() ) return 0;
  return (TMucDigi*)m_mucDigiCol->At( i );
}
 
/// Lumi
void TDigiEvent::addLumiDigi( TLumiDigi* digi ) { m_lumiDigiCol->Add( digi ); }
 
const TLumiDigi* TDigiEvent::getLumiDigi( Int_t i ) const {
  if ( i >= m_lumiDigiCol->GetEntries() ) return 0;
  return (TLumiDigi*)m_lumiDigiCol->At( i );
}