TRecTrackEvent.cxx

Go to the documentation of this file.

#include "RootEventData/TRecTrackEvent.h"
#include "TCollection.h" // Declares TIter
 
ClassImp( TRecTrackEvent );
 
// Allocate the TObjArray just once
 
TObjArray* TRecTrackEvent::s_staticRecMdcTrackCol       = 0;
TObjArray* TRecTrackEvent::s_staticRecMdcHitCol         = 0;
TObjArray* TRecTrackEvent::s_staticTofTrackCol          = 0;
TObjArray* TRecTrackEvent::s_staticEmcHitCol            = 0;
TObjArray* TRecTrackEvent::s_staticEmcClusterCol        = 0;
TObjArray* TRecTrackEvent::s_staticEmcShowerCol         = 0;
TObjArray* TRecTrackEvent::s_staticMucTrackCol          = 0;
TObjArray* TRecTrackEvent::s_staticRecMdcDedxCol        = 0;
TObjArray* TRecTrackEvent::s_staticRecMdcDedxHitCol     = 0;
TObjArray* TRecTrackEvent::s_staticExtTrackCol          = 0;
TObjArray* TRecTrackEvent::s_staticRecMdcKalTrackCol    = 0;
TObjArray* TRecTrackEvent::s_staticRecMdcKalHelixSegCol = 0;
TObjArray* TRecTrackEvent::s_staticEvTimeCol            = 0;
TObjArray* TRecTrackEvent::s_staticRecZddChannelCol     = 0;
 
//***************************************************************
TRecTrackEvent::TRecTrackEvent() {
  // Dst Track
  // Rec Track
  if ( !s_staticRecMdcTrackCol ) { s_staticRecMdcTrackCol = new TObjArray(); }
  m_recMdcTrackCol = s_staticRecMdcTrackCol;
 
  if ( !s_staticRecMdcHitCol ) { s_staticRecMdcHitCol = new TObjArray(); }
  m_recMdcHitCol = s_staticRecMdcHitCol;
 
  if ( !s_staticTofTrackCol ) { s_staticTofTrackCol = new TObjArray(); }
  m_recTofTrackCol = s_staticTofTrackCol;
 
  if ( !s_staticEmcHitCol ) { s_staticEmcHitCol = new TObjArray(); }
  m_recEmcHitCol = s_staticEmcHitCol;
 
  if ( !s_staticEmcClusterCol ) { s_staticEmcClusterCol = new TObjArray(); }
  m_recEmcClusterCol = s_staticEmcClusterCol;
 
  if ( !s_staticEmcShowerCol ) { s_staticEmcShowerCol = new TObjArray(); }
  m_recEmcShowerCol = s_staticEmcShowerCol;
 
  if ( !s_staticMucTrackCol ) { s_staticMucTrackCol = new TObjArray(); }
  m_recMucTrackCol = s_staticMucTrackCol;
 
  if ( !s_staticRecMdcDedxCol ) { s_staticRecMdcDedxCol = new TObjArray(); }
  m_recMdcDedxCol = s_staticRecMdcDedxCol;
 
  if ( !s_staticRecMdcDedxHitCol ) { s_staticRecMdcDedxHitCol = new TObjArray(); }
  m_recMdcDedxHitCol = s_staticRecMdcDedxHitCol;
 
  if ( !s_staticExtTrackCol ) { s_staticExtTrackCol = new TObjArray(); }
  m_recExtTrackCol = s_staticExtTrackCol;
 
  if ( !s_staticRecMdcKalTrackCol ) { s_staticRecMdcKalTrackCol = new TObjArray(); }
  m_recMdcKalTrackCol = s_staticRecMdcKalTrackCol;
 
  if ( !s_staticRecMdcKalHelixSegCol ) { s_staticRecMdcKalHelixSegCol = new TObjArray(); }
  m_recMdcKalHelixSegCol = s_staticRecMdcKalHelixSegCol;
 
  if ( !s_staticEvTimeCol ) { s_staticEvTimeCol = new TObjArray(); }
  m_recEvTimeCol = s_staticEvTimeCol;
 
  if ( !s_staticRecZddChannelCol ) { s_staticRecZddChannelCol = new TObjArray(); }
  m_recZddChannelCol = s_staticRecZddChannelCol;
 
  Clear();
}
 
//*****************************************************************
TRecTrackEvent::~TRecTrackEvent() {
 
  /****************************    Dst Track *************************/
  if ( m_recMdcTrackCol == s_staticRecMdcTrackCol ) s_staticRecMdcTrackCol = 0;
  m_recMdcTrackCol->Delete();
  delete m_recMdcTrackCol;
  m_recMdcTrackCol = 0;
 
  if ( m_recMdcHitCol == s_staticRecMdcHitCol ) s_staticRecMdcHitCol = 0;
  m_recMdcHitCol->Delete();
  delete m_recMdcHitCol;
  m_recMdcHitCol = 0;
 
  if ( m_recTofTrackCol == s_staticTofTrackCol ) s_staticTofTrackCol = 0;
  m_recTofTrackCol->Delete();
  delete m_recTofTrackCol;
  m_recTofTrackCol = 0;
 
  if ( m_recEmcHitCol == s_staticEmcHitCol ) s_staticEmcHitCol = 0;
  m_recEmcHitCol->Delete();
  delete m_recEmcHitCol;
  m_recEmcHitCol = 0;
 
  if ( m_recEmcClusterCol == s_staticEmcClusterCol ) s_staticEmcClusterCol = 0;
  m_recEmcClusterCol->Delete();
  delete m_recEmcClusterCol;
  m_recEmcClusterCol = 0;
 
  if ( m_recEmcShowerCol == s_staticEmcShowerCol ) s_staticEmcShowerCol = 0;
  m_recEmcShowerCol->Delete();
  delete m_recEmcShowerCol;
  m_recEmcShowerCol = 0;
 
  if ( m_recMucTrackCol == s_staticMucTrackCol ) s_staticMucTrackCol = 0;
  m_recMucTrackCol->Delete();
  delete m_recMucTrackCol;
  m_recMucTrackCol = 0;
 
  if ( m_recMdcDedxCol == s_staticRecMdcDedxCol ) s_staticRecMdcDedxCol = 0;
  m_recMdcDedxCol->Delete();
  delete m_recMdcDedxCol;
  m_recMdcDedxCol = 0;
 
  if ( m_recMdcDedxHitCol == s_staticRecMdcDedxHitCol ) s_staticRecMdcDedxHitCol = 0;
  m_recMdcDedxHitCol->Delete();
  delete m_recMdcDedxHitCol;
  m_recMdcDedxHitCol = 0;
 
  if ( m_recExtTrackCol == s_staticExtTrackCol ) s_staticExtTrackCol = 0;
  m_recExtTrackCol->Delete();
  delete m_recExtTrackCol;
  m_recExtTrackCol = 0;
 
  if ( m_recMdcKalTrackCol == s_staticRecMdcKalTrackCol ) s_staticRecMdcKalTrackCol = 0;
  m_recMdcKalTrackCol->Delete();
  delete m_recMdcKalTrackCol;
  m_recMdcKalTrackCol = 0;
 
  if ( m_recMdcKalHelixSegCol == s_staticRecMdcKalHelixSegCol )
    s_staticRecMdcKalHelixSegCol = 0;
  m_recMdcKalHelixSegCol->Delete();
  delete m_recMdcKalHelixSegCol;
  m_recMdcKalHelixSegCol = 0;
 
  if ( m_recEvTimeCol == s_staticEvTimeCol ) s_staticEvTimeCol = 0;
  m_recEvTimeCol->Delete();
  delete m_recEvTimeCol;
  m_recEvTimeCol = 0;
 
  if ( m_recZddChannelCol == s_staticRecZddChannelCol ) s_staticRecZddChannelCol = 0;
  m_recZddChannelCol->Delete();
  delete m_recZddChannelCol;
  m_recZddChannelCol = 0;
}
 
//*****************************************************************
void TRecTrackEvent::initialize() {}
 
//*****************************************************************
void TRecTrackEvent::Clear( Option_t* option ) {}
 
//*****************************************************************************
void TRecTrackEvent::Print( Option_t* option ) const { TObject::Print( option ); }
 
/****************     Dst Track     ************************/
/// Mdc
void TRecTrackEvent::addRecMdcTrack( TRecMdcTrack* Track ) { m_recMdcTrackCol->Add( Track ); }
 
const TRecMdcTrack* TRecTrackEvent::getRecMdcTrack( Int_t i ) const {
  if ( Int_t( i ) >= m_recMdcTrackCol->GetEntries() ) return 0;
  return (TRecMdcTrack*)m_recMdcTrackCol->At( i );
}
 
void TRecTrackEvent::addRecMdcHit( TRecMdcHit* Hit ) { m_recMdcHitCol->Add( Hit ); }
 
const TRecMdcHit* TRecTrackEvent::getRecMdcHit( Int_t i ) const {
  if ( Int_t( i ) >= m_recMdcHitCol->GetEntries() ) return 0;
  return (TRecMdcHit*)m_recMdcHitCol->At( i );
}
 
/// Tof
void TRecTrackEvent::addTofTrack( TRecTofTrack* Track ) { m_recTofTrackCol->Add( Track ); }
 
const TRecTofTrack* TRecTrackEvent::getTofTrack( Int_t i ) const {
  if ( Int_t( i ) >= m_recTofTrackCol->GetEntries() ) return 0;
  return (TRecTofTrack*)m_recTofTrackCol->At( i );
}
 
/// Emc
void TRecTrackEvent::addEmcHit( TRecEmcHit* Track ) { m_recEmcHitCol->Add( Track ); }
 
const TRecEmcHit* TRecTrackEvent::getEmcHit( Int_t i ) const {
  if ( Int_t( i ) >= m_recEmcHitCol->GetEntries() ) return 0;
  return (TRecEmcHit*)m_recEmcHitCol->At( i );
}
 
void TRecTrackEvent::addEmcCluster( TRecEmcCluster* Track ) {
  m_recEmcClusterCol->Add( Track );
}
 
const TRecEmcCluster* TRecTrackEvent::getEmcCluster( Int_t i ) const {
  if ( Int_t( i ) >= m_recEmcClusterCol->GetEntries() ) return 0;
  return (TRecEmcCluster*)m_recEmcClusterCol->At( i );
}
 
void TRecTrackEvent::addEmcShower( TRecEmcShower* Track ) { m_recEmcShowerCol->Add( Track ); }
 
const TRecEmcShower* TRecTrackEvent::getEmcShower( Int_t i ) const {
  if ( Int_t( i ) >= m_recEmcShowerCol->GetEntries() ) return 0;
  return (TRecEmcShower*)m_recEmcShowerCol->At( i );
}
 
/// Muc
void TRecTrackEvent::addMucTrack( TRecMucTrack* Track ) { m_recMucTrackCol->Add( Track ); }
 
const TRecMucTrack* TRecTrackEvent::getMucTrack( Int_t i ) const {
  if ( Int_t( i ) >= m_recMucTrackCol->GetEntries() ) return 0;
  return (TRecMucTrack*)m_recMucTrackCol->At( i );
}
 
/// Dedx
void TRecTrackEvent::addRecMdcDedx( TRecMdcDedx* Track ) { m_recMdcDedxCol->Add( Track ); }
 
const TRecMdcDedx* TRecTrackEvent::getRecMdcDedx( Int_t i ) const {
  if ( Int_t( i ) >= m_recMdcDedxCol->GetEntries() ) return 0;
  return (TRecMdcDedx*)m_recMdcDedxCol->At( i );
}
 
void TRecTrackEvent::addRecMdcDedxHit( TRecMdcDedxHit* Track ) {
  m_recMdcDedxHitCol->Add( Track );
}
 
const TRecMdcDedxHit* TRecTrackEvent::getRecMdcDedxHit( Int_t i ) const {
  if ( Int_t( i ) >= m_recMdcDedxHitCol->GetEntries() ) return 0;
  return (TRecMdcDedxHit*)m_recMdcDedxHitCol->At( i );
}
 
// // Ext
void TRecTrackEvent::addExtTrack( TRecExtTrack* Track ) { m_recExtTrackCol->Add( Track ); }
 
const TRecExtTrack* TRecTrackEvent::getExtTrack( Int_t i ) const {
  if ( Int_t( i ) >= m_recExtTrackCol->GetEntries() ) return 0;
  return (TRecExtTrack*)m_recExtTrackCol->At( i );
}
 
// RecMdcKal
void TRecTrackEvent::addRecMdcKalTrack( TRecMdcKalTrack* Track ) {
  m_recMdcKalTrackCol->Add( Track );
}
 
const TRecMdcKalTrack* TRecTrackEvent::getRecMdcKalTrack( Int_t i ) const {
  if ( Int_t( i ) >= m_recMdcKalTrackCol->GetEntries() ) return 0;
  return (TRecMdcKalTrack*)m_recMdcKalTrackCol->At( i );
}
 
void TRecTrackEvent::addRecMdcKalHelixSeg( TRecMdcKalHelixSeg* Track ) {
  m_recMdcKalHelixSegCol->Add( Track );
}
 
const TRecMdcKalHelixSeg* TRecTrackEvent::getRecMdcKalHelixSeg( Int_t i ) const {
  if ( Int_t( i ) >= m_recMdcKalHelixSegCol->GetEntries() ) return 0;
  return (TRecMdcKalHelixSeg*)m_recMdcKalHelixSegCol->At( i );
}
 
// EsTime
void TRecTrackEvent::addEvTime( TRecEvTime* Track ) { m_recEvTimeCol->Add( Track ); }
 
const TRecEvTime* TRecTrackEvent::getEvTime( Int_t i ) const {
  if ( Int_t( i ) >= m_recEvTimeCol->GetEntries() ) return 0;
  return (TRecEvTime*)m_recEvTimeCol->At( i );
}
 
// ZDD
void TRecTrackEvent::addRecZddChannel( TRecZddChannel* zdd ) {
  m_recZddChannelCol->Add( zdd );
}
 
const TRecZddChannel* TRecTrackEvent::getRecZddChannel( Int_t i ) const {
  if ( i >= m_recZddChannelCol->GetEntries() || i < 0 ) return 0;
  return (TRecZddChannel*)m_recZddChannelCol->At( i );
}