commonData Class Reference

#include <commonData.h>

Public Member Functions
	commonData ()
	~commonData ()
void	clear ()

Static Public Attributes
static TEvtHeader *	m_EvtHeader = NULL
static TEvtNavigator *	m_EvtNavigator = NULL
static std::map< const MdcDigi *, TRef >	m_mdcDigiMap
	Create a set of maps between Digi data in the TDS and the TRefs in the ROOT file.
static std::map< const CgemDigi *, TRef >	m_cgemDigiMap
static std::map< const TObject *, const MdcDigi * >	m_rootMdcDigiMap
	Create a set of maps between ROOT Digi objects and TDS Digi data.
static std::map< const TObject *, const CgemDigi * >	m_rootCgemDigiMap
static TDigiEvent *	m_recEvt = NULL
	Provide access to the ROOT event pointers.
static std::map< const EmcDigi *, TRef >	m_emcDigiMap
static std::map< const TObject *, const EmcDigi * >	m_rootEmcDigiMap
static std::map< const TofDigi *, TRef >	m_tofDigiMap
static std::map< const TObject *, const TofDigi * >	m_rootTofDigiMap
static std::map< const MucDigi *, TRef >	m_mucDigiMap
static std::map< const TObject *, const MucDigi * >	m_rootMucDigiMap
static std::map< const LumiDigi *, TRef >	m_lumiDigiMap
static std::map< const TObject *, const LumiDigi * >	m_rootLumiDigiMap
static TDstEvent *	m_dstEvt = NULL
	Provide access to the ROOT event pointers.
static std::map< const DstEmcShower *, TRef >	m_emcShowerMap
static std::map< const TObject *, const DstEmcShower * >	m_rootEmcShowerMap
static std::map< const DstMdcTrack *, TRef >	m_mdcTrackMap
static std::map< const TObject *, const DstMdcTrack * >	m_rootMdcTrackMap
static std::map< const DstCgemTrack *, TRef >	m_cgemTrackMap
static std::map< const TObject *, const DstCgemTrack * >	m_rootCgemTrackMap
static std::map< const DstCgemSegment *, TRef >	m_cgemSegmentMap
static std::map< const TObject *, const DstCgemSegment * >	m_rootCgemSegmentMap
static std::map< const DstMucTrack *, TRef >	m_mucTrackMap
static std::map< const TObject *, const DstMucTrack * >	m_rootMucTrackMap
static std::map< const DstTofTrack *, TRef >	m_tofTrackMap
static std::map< const TObject *, const DstTofTrack * >	m_rootTofTrackMap
static std::map< const DstMdcDedx *, TRef >	m_mdcDedxMap
static std::map< const TObject *, const DstMdcDedx * >	m_rootMdcDedxMap
static std::map< const DstCgemDedx *, TRef >	m_cgemDedxMap
static std::map< const TObject *, const DstCgemDedx * >	m_rootCgemDedxMap
static std::map< const DstExtTrack *, TRef >	m_extTrackMap
static std::map< const TObject *, const DstExtTrack * >	m_rootExtTrackMap
static std::map< const DstMdcKalTrack *, TRef >	m_mdcKalTrackMap
static std::map< const TObject *, const DstMdcKalTrack * >	m_rootMdcKalTrackMap
static std::map< const DstCgemKalTrack *, TRef >	m_cgemKalTrackMap
static std::map< const TObject *, const DstCgemKalTrack * >	m_rootCgemKalTrackMap
static TMcEvent *	m_mcEvt = NULL
	Provide access to the ROOT event pointers.
static std::map< const EmcMcHit *, TRef >	m_emcMcHitMap
static std::map< const TObject *, const EmcMcHit * >	m_rootEmcMcHitMap
static std::map< const MdcMcHit *, TRef >	m_mdcMcHitMap
static std::map< const TObject *, const MdcMcHit * >	m_rootMdcMcHitMap
static std::map< const CgemMcHit *, TRef >	m_cgemMcHitMap
static std::map< const TObject *, const CgemMcHit * >	m_rootCgemMcHitMap
static std::map< const TofMcHit *, TRef >	m_tofMcHitMap
static std::map< const TObject *, const TofMcHit * >	m_rootTofMcHitMap
static std::map< const MucMcHit *, TRef >	m_mucMcHitMap
static std::map< const TObject *, const MucMcHit * >	m_rootMucMcHitMap
static std::map< const McParticle *, TRef >	m_mcParticleMap
static std::map< const TObject *, const McParticle * >	m_rootMcParticleMap
static TTrigEvent *	m_trigEvt = NULL
	Provide access to the ROOT event pointers.
static std::map< const TrigData *, TRef >	m_trigDataMap
static std::map< const TObject *, const TrigData * >	m_rootTrigDataMap
static THltEvent *	m_hltEvt = NULL
	Provide access to the ROOT event pointers.
static std::map< const HltRaw *, TRef >	m_hltRawMap
static std::map< const TObject *, const HltRaw * >	m_rootHltRawMap
static std::map< const HltInf *, TRef >	m_hltInfMap
static std::map< const TObject *, const HltInf * >	m_rootHltInfMap
static std::map< const DstHltInf *, TRef >	m_dstHltInfMap
static std::map< const TObject *, const DstHltInf * >	m_rootDstHltInfMap
static TRecTrackEvent *	m_rectrackEvt = NULL
	Provide access to the ROOT event pointers.
static std::map< const RecMdcTrack *, TRef >	m_recMdcTrackMap
static std::map< const TObject *, const RecMdcTrack * >	m_rootRecMdcTrackMap
static std::map< const RecMdcHit *, TRef >	m_recMdcHitMap
static std::map< const TObject *, const RecMdcHit * >	m_rootRecMdcHitMap
static std::map< const RecCgemTrack *, TRef >	m_recCgemTrackMap
static std::map< const TObject *, const RecCgemTrack * >	m_rootRecCgemTrackMap
static std::map< const RecCgemSegment *, TRef >	m_recCgemSegmentMap
static std::map< const TObject *, const RecCgemSegment * >	m_rootRecCgemSegmentMap
static std::map< const RecCgemHit *, TRef >	m_recCgemHitMap
static std::map< const TObject *, const RecCgemHit * >	m_rootRecCgemHitMap
static std::map< const RecCgemCluster *, TRef >	m_recCgemClusterMap
static std::map< const TObject *, const RecCgemCluster * >	m_rootRecCgemClusterMap
static std::map< const RecTofTrack *, TRef >	m_RecTofTrackMap
static std::map< const TObject *, const RecTofTrack * >	m_rootRecTofTrackMap
static std::map< const RecEmcHit *, TRef >	m_recEmcHitMap
static std::map< const TObject *, const RecEmcHit * >	m_rootRecEmcHitMap
static std::map< const RecEmcCluster *, TRef >	m_recEmcClusterMap
static std::map< const TObject *, const RecEmcCluster * >	m_rootRecEmcClusterMap
static std::map< const RecEmcShower *, TRef >	m_recEmcShowerMap
static std::map< const TObject *, const RecEmcShower * >	m_rootRecEmcShowerMap
static std::map< const RecMucTrack *, TRef >	m_RecMucTrackMap
static std::map< const TObject *, const RecMucTrack * >	m_rootRecMucTrackMap
static std::map< const RecMdcDedx *, TRef >	m_recMdcDedxMap
static std::map< const TObject *, const RecMdcDedx * >	m_rootRecMdcDedxMap
static std::map< const RecMdcDedxHit *, TRef >	m_recMdcDedxHitMap
static std::map< const TObject *, const RecMdcDedxHit * >	m_rootRecMdcDedxHitMap
static std::map< const RecCgemDedx *, TRef >	m_recCgemDedxMap
static std::map< const TObject *, const RecCgemDedx * >	m_rootRecCgemDedxMap
static std::map< const RecCgemDedxHit *, TRef >	m_recCgemDedxHitMap
static std::map< const TObject *, const RecCgemDedxHit * >	m_rootRecCgemDedxHitMap
static std::map< const RecMdcKalTrack *, TRef >	m_recMdcKalTrackMap
static std::map< const TObject *, const RecMdcKalTrack * >	m_rootRecMdcKalTrackMap
static std::map< const RecMdcKalHelixSeg *, TRef >	m_recMdcKalHelixSegMap
static std::map< const TObject *, const RecMdcKalHelixSeg * >	m_rootRecMdcKalHelixSegMap
static std::map< const RecCgemKalTrack *, TRef >	m_recCgemKalTrackMap
static std::map< const TObject *, const RecCgemKalTrack * >	m_rootRecCgemKalTrackMap
static std::map< const RecCgemKalHelixSeg *, TRef >	m_recCgemKalHelixSegMap
static std::map< const TObject *, const RecCgemKalHelixSeg * >	m_rootRecCgemKalHelixSegMap
static std::map< const RecEsTime *, TRef >	m_RecEvTimeMap
static std::map< const TObject *, const RecEsTime * >	m_rootRecEvTimeMap
static std::map< const RecZddChannel *, TRef >	m_recZddChannelMap
static std::map< const TObject *, const RecZddChannel * >	m_rootRecZddChannelMap
static std::map< const EvtRecVeeVertex *, TRef >	m_evtRecVeeVertexMap
static std::map< const TObject *, const EvtRecVeeVertex * >	m_rootEvtRecVeeVertexMap
static std::map< const EvtRecPi0 *, TRef >	m_evtRecPi0Map
static std::map< const TObject *, const EvtRecPi0 * >	m_rootEvtRecPi0Map
static std::map< const EvtRecEtaToGG *, TRef >	m_evtRecEtaToGGMap
static std::map< const TObject *, const EvtRecEtaToGG * >	m_rootEvtRecEtaToGGMap
static std::map< const EvtRecDTag *, TRef >	m_evtRecDTagMap
static std::map< const TObject *, const EvtRecDTag * >	m_rootEvtRecDTagMap
static TEvtRecObject *	m_evtRecObject = NULL
static std::map< const EvtRecTrack *, TRef >	m_EvtRecTrackMap
static std::map< const TObject *, const EvtRecTrack * >	m_rootEvtRecTrackMap

Detailed Description

Definition at line 126 of file commonData.h.

Constructor & Destructor Documentation

commonData()

commonData::commonData ( )

inline

Definition at line 130 of file commonData.h.

{  }; 

~commonData()

commonData::~commonData ( )

inline

Definition at line 131 of file commonData.h.

{  };

Member Function Documentation

clear()

void commonData::clear

(

)

Definition at line 192 of file commonData.cxx.

                       { 
//for digi
 
  if (m_recEvt != NULL) {
    delete m_recEvt;
    m_recEvt = NULL;
  }
  if (m_dstEvt != NULL) {
    delete m_dstEvt;
    m_dstEvt = NULL;
  }
  if (m_mcEvt != NULL) {
    delete m_mcEvt;
    m_mcEvt = NULL;
  }
  if (m_rectrackEvt != NULL) {  //2007-10-04
    delete m_rectrackEvt;
    m_rectrackEvt = NULL;
  }
  if (m_EvtHeader != NULL){
    delete m_EvtHeader;
    m_EvtHeader = NULL;
  }
  if (m_EvtNavigator != NULL){
    delete m_EvtNavigator;
    m_EvtNavigator = NULL;
  }
  if(m_trigEvt != NULL){
    delete m_trigEvt;
    m_trigEvt = NULL;
  }
  if(m_hltEvt != NULL){
    delete m_hltEvt;
    m_hltEvt = NULL;
  } 
  if ( m_evtRecObject != NULL ) {
     delete m_evtRecObject;
     m_evtRecObject = NULL;
  }
  
  for (std::map<const MdcDigi*, TRef>::iterator iter = m_mdcDigiMap.begin();
      iter != m_mdcDigiMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_mdcDigiMap.clear();
  for (std::map<const TObject*, const MdcDigi*>::iterator iter = m_rootMdcDigiMap.begin();
      iter != m_rootMdcDigiMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootMdcDigiMap.clear();
  
  for (std::map<const CgemDigi*, TRef>::iterator iter = m_cgemDigiMap.begin();
      iter != m_cgemDigiMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_cgemDigiMap.clear();
  for (std::map<const TObject*, const CgemDigi*>::iterator iter = m_rootCgemDigiMap.begin();
      iter != m_rootCgemDigiMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootCgemDigiMap.clear();
  
  for (std::map<const EmcDigi*, TRef>::iterator iter = m_emcDigiMap.begin();
      iter != m_emcDigiMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_emcDigiMap.clear();
  for (std::map<const TObject*, const  EmcDigi*>::iterator iter = m_rootEmcDigiMap.begin();
      iter != m_rootEmcDigiMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootEmcDigiMap.clear();
  
  for (std::map<const TofDigi*, TRef>::iterator iter = m_tofDigiMap.begin();
      iter != m_tofDigiMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_tofDigiMap.clear();
  for (std::map<const TObject*, const  TofDigi*>::iterator iter = m_rootTofDigiMap.begin();
      iter != m_rootTofDigiMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootTofDigiMap.clear();
  
  for (std::map<const MucDigi*, TRef>::iterator iter = m_mucDigiMap.begin();
      iter != m_mucDigiMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_mucDigiMap.clear();
  for (std::map<const TObject*, const  MucDigi*>::iterator iter = m_rootMucDigiMap.begin();
      iter != m_rootMucDigiMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootMucDigiMap.clear();
 
  for ( std::map<const LumiDigi*, TRef>::iterator iter = m_lumiDigiMap.begin();
    iter != m_lumiDigiMap.end(); ++iter) {
     delete (*iter).second.GetObject();
     delete (*iter).first;
  }
  m_lumiDigiMap.clear();
  for ( std::map<const TObject*, const LumiDigi*>::iterator iter = m_rootLumiDigiMap.begin();
    iter != m_rootLumiDigiMap.end(); ++iter) {
     delete (*iter).first;
  }
  m_rootLumiDigiMap.clear();
  
  //for dst
  for (std::map<const DstEmcShower*, TRef>::iterator iter = m_emcShowerMap.begin();
      iter != m_emcShowerMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_emcShowerMap.clear();
  for (std::map<const TObject*, const  DstEmcShower*>::iterator iter = m_rootEmcShowerMap.begin();
      iter != m_rootEmcShowerMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootEmcShowerMap.clear();
  /*
  for (std::map<const DstMdcTrack*, TRef>::iterator p = m_mdcTrackMap.begin(); p != m_mdcTrackMap.end();p++){
    std::cout << "********The first is ****************" << (*p).first <<endl;
    //std::cout << "*********The second is " << (*p).second <<endl;
    }
  */
  for (std::map<const DstMdcTrack*, TRef>::iterator iter = m_mdcTrackMap.begin();
      iter != m_mdcTrackMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_mdcTrackMap.clear();
  for (std::map<const TObject*, const  DstMdcTrack*>::iterator iter = m_rootMdcTrackMap.begin();
      iter != m_rootMdcTrackMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootMdcTrackMap.clear();
  
  for (std::map<const DstCgemTrack*, TRef>::iterator iter = m_cgemTrackMap.begin();
      iter != m_cgemTrackMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_cgemTrackMap.clear();
  for (std::map<const TObject*, const  DstCgemTrack*>::iterator iter = m_rootCgemTrackMap.begin();
      iter != m_rootCgemTrackMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootCgemTrackMap.clear();
  
  for (std::map<const DstCgemSegment*, TRef>::iterator iter = m_cgemSegmentMap.begin();
      iter != m_cgemSegmentMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_cgemSegmentMap.clear();
  for (std::map<const TObject*, const  DstCgemSegment*>::iterator iter = m_rootCgemSegmentMap.begin();
      iter != m_rootCgemSegmentMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootCgemSegmentMap.clear();
  
  for (std::map<const DstMucTrack*, TRef>::iterator iter = m_mucTrackMap.begin();
      iter != m_mucTrackMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_mucTrackMap.clear();
  for (std::map<const TObject*, const  DstMucTrack*>::iterator iter = m_rootMucTrackMap.begin();
      iter != m_rootMucTrackMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootMucTrackMap.clear(); 
  
  for (std::map<const DstTofTrack*, TRef>::iterator iter = m_tofTrackMap.begin();
      iter != m_tofTrackMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_tofTrackMap.clear();
  for (std::map<const TObject*, const  DstTofTrack*>::iterator iter = m_rootTofTrackMap.begin();
      iter != m_rootTofTrackMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootTofTrackMap.clear(); 
  
  for (std::map<const DstMdcDedx*, TRef>::iterator iter = m_mdcDedxMap.begin();
      iter != m_mdcDedxMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_mdcDedxMap.clear();
  for (std::map<const TObject*, const  DstMdcDedx*>::iterator iter = m_rootMdcDedxMap.begin();
      iter != m_rootMdcDedxMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootMdcDedxMap.clear(); 
  
  for (std::map<const DstCgemDedx*, TRef>::iterator iter = m_cgemDedxMap.begin();
      iter != m_cgemDedxMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_cgemDedxMap.clear();
  for (std::map<const TObject*, const  DstCgemDedx*>::iterator iter = m_rootCgemDedxMap.begin();
      iter != m_rootCgemDedxMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootCgemDedxMap.clear(); 
  
  for (std::map<const DstExtTrack*, TRef>::iterator iter = m_extTrackMap.begin();
      iter != m_extTrackMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_extTrackMap.clear();
  for (std::map<const TObject*, const  DstExtTrack*>::iterator iter = m_rootExtTrackMap.begin();
      iter != m_rootExtTrackMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootExtTrackMap.clear();
  
  for (std::map<const DstMdcKalTrack*, TRef>::iterator iter = m_mdcKalTrackMap.begin();
      iter != m_mdcKalTrackMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_mdcKalTrackMap.clear();
  for (std::map<const TObject*, const  DstMdcKalTrack*>::iterator iter = m_rootMdcKalTrackMap.begin();
      iter != m_rootMdcKalTrackMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootMdcKalTrackMap.clear();
  // for McTruth
  for (std::map<const MdcMcHit*, TRef>::iterator iter = m_mdcMcHitMap.begin();
      iter != m_mdcMcHitMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_mdcMcHitMap.clear();
  for (std::map<const TObject*, const MdcMcHit*>::iterator iter = m_rootMdcMcHitMap.begin();
      iter != m_rootMdcMcHitMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootMdcMcHitMap.clear();
  
  for (std::map<const DstCgemKalTrack*, TRef>::iterator iter = m_cgemKalTrackMap.begin();
      iter != m_cgemKalTrackMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_cgemKalTrackMap.clear();
  for (std::map<const TObject*, const  DstCgemKalTrack*>::iterator iter = m_rootCgemKalTrackMap.begin();
      iter != m_rootCgemKalTrackMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootCgemKalTrackMap.clear();
  // for McTruth
  for (std::map<const CgemMcHit*, TRef>::iterator iter = m_cgemMcHitMap.begin();
      iter != m_cgemMcHitMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_cgemMcHitMap.clear();
  for (std::map<const TObject*, const CgemMcHit*>::iterator iter = m_rootCgemMcHitMap.begin();
      iter != m_rootCgemMcHitMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootCgemMcHitMap.clear();
  
  for (std::map<const EmcMcHit*, TRef>::iterator iter = m_emcMcHitMap.begin();
      iter != m_emcMcHitMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_emcMcHitMap.clear();
  for (std::map<const TObject*, const  EmcMcHit*>::iterator iter = m_rootEmcMcHitMap.begin();
      iter != m_rootEmcMcHitMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootEmcMcHitMap.clear();
  
  for (std::map<const TofMcHit*, TRef>::iterator iter = m_tofMcHitMap.begin();
      iter != m_tofMcHitMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_tofMcHitMap.clear();
  for (std::map<const TObject*, const  TofMcHit*>::iterator iter = m_rootTofMcHitMap.begin();
      iter != m_rootTofMcHitMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootTofMcHitMap.clear();
  
  for (std::map<const MucMcHit*, TRef>::iterator iter = m_mucMcHitMap.begin();
      iter != m_mucMcHitMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_mucMcHitMap.clear();
  for (std::map<const TObject*, const  MucMcHit*>::iterator iter = m_rootMucMcHitMap.begin();
      iter != m_rootMucMcHitMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootMucMcHitMap.clear();
  
  for (std::map<const McParticle*, TRef>::iterator iter = m_mcParticleMap.begin();
      iter != m_mcParticleMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_mcParticleMap.clear();
  for (std::map<const TObject*, const  McParticle*>::iterator iter = m_rootMcParticleMap.begin();
      iter != m_rootMcParticleMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootMcParticleMap.clear();
 
  //m_decayModeMap.clear();
  //m_rootDecayModeMap.clear();
 
//m_decayModeMap.clear();
//m_rootDecayModeMap.clear();
 
  //for Trig
  m_trigDataMap.clear();
  m_rootTrigDataMap.clear();
 
  //for event filter
  for (std::map<const HltRaw*, TRef>::iterator iter = m_hltRawMap.begin();
       iter != m_hltRawMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_hltRawMap.clear();
  for (std::map<const TObject*, const  HltRaw*>::iterator iter = m_rootHltRawMap.begin();
       iter != m_rootHltRawMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootHltRawMap.clear();
  m_hltInfMap.clear();
  m_rootHltInfMap.clear();
  m_dstHltInfMap.clear();
  m_rootDstHltInfMap.clear();
  //for Rec
  //Mdc
  for (std::map<const RecMdcTrack*, TRef>::iterator iter = m_recMdcTrackMap.begin();
      iter != m_recMdcTrackMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_recMdcTrackMap.clear();
  for (std::map<const TObject*, const  RecMdcTrack*>::iterator iter = m_rootRecMdcTrackMap.begin();
      iter != m_rootRecMdcTrackMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootRecMdcTrackMap.clear(); 
  for (std::map<const RecMdcHit*, TRef>::iterator iter = m_recMdcHitMap.begin();
      iter != m_recMdcHitMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_recMdcHitMap.clear();
  for (std::map<const TObject*, const  RecMdcHit*>::iterator iter = m_rootRecMdcHitMap.begin();
      iter != m_rootRecMdcHitMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootRecMdcHitMap.clear(); 
 
  //Cgem
  for (std::map<const RecCgemTrack*, TRef>::iterator iter = m_recCgemTrackMap.begin();
      iter != m_recCgemTrackMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_recCgemTrackMap.clear();
  for (std::map<const TObject*, const  RecCgemTrack*>::iterator iter = m_rootRecCgemTrackMap.begin();
      iter != m_rootRecCgemTrackMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootRecCgemTrackMap.clear(); 
 
  for (std::map<const RecCgemSegment*, TRef>::iterator iter = m_recCgemSegmentMap.begin();
      iter != m_recCgemSegmentMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_recCgemSegmentMap.clear();
  for (std::map<const TObject*, const  RecCgemSegment*>::iterator iter = m_rootRecCgemSegmentMap.begin();
      iter != m_rootRecCgemSegmentMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootRecCgemSegmentMap.clear(); 
 
  for (std::map<const RecCgemHit*, TRef>::iterator iter = m_recCgemHitMap.begin();
      iter != m_recCgemHitMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_recCgemHitMap.clear();
  for (std::map<const TObject*, const  RecCgemHit*>::iterator iter = m_rootRecCgemHitMap.begin();
      iter != m_rootRecCgemHitMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootRecCgemHitMap.clear();
  for (std::map<const RecCgemCluster*, TRef>::iterator iter = m_recCgemClusterMap.begin();
         iter != m_recCgemClusterMap.end();iter++){
     delete (*iter).second.GetObject();
     delete (*iter).first;
  }
  m_recCgemClusterMap.clear();
//  for (std::map<const RecCgemSegment*, TRef>::iterator iter = m_recCgemSegmentMap.begin();
//       iter != m_recCgemSegmentMap.end();iter++){
//   delete (*iter).second.GetObject();
//   delete (*iter).first;
//  }
//  m_recCgemSegmentMap.clear();
  for (std::map<const TObject*, const RecCgemCluster*>::iterator iter = m_rootRecCgemClusterMap.begin();
         iter != m_rootRecCgemClusterMap.end();iter++){
     delete (*iter).first;
  }
  m_rootRecCgemClusterMap.clear(); 
 
//for Rec
  for (std::map<const RecEmcHit*, TRef>::iterator iter = m_recEmcHitMap.begin();
      iter != m_recEmcHitMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_recEmcHitMap.clear();
  for (std::map<const TObject*, const  RecEmcHit*>::iterator iter = m_rootRecEmcHitMap.begin();
      iter != m_rootRecEmcHitMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootRecEmcHitMap.clear();
 
  for (std::map<const RecEmcCluster*, TRef>::iterator iter = m_recEmcClusterMap.begin();
      iter != m_recEmcClusterMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_recEmcClusterMap.clear();
  for (std::map<const TObject*, const  RecEmcCluster*>::iterator iter = m_rootRecEmcClusterMap.begin();
      iter != m_rootRecEmcClusterMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootRecEmcClusterMap.clear();
 
  for (std::map<const RecEmcShower*, TRef>::iterator iter = m_recEmcShowerMap.begin();
      iter != m_recEmcShowerMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_recEmcShowerMap.clear();
  for (std::map<const TObject*, const  RecEmcShower*>::iterator iter = m_rootRecEmcShowerMap.begin();
      iter != m_rootRecEmcShowerMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootRecEmcShowerMap.clear();
 
  for (std::map<const RecTofTrack*, TRef>::iterator iter = m_RecTofTrackMap.begin();
       iter != m_RecTofTrackMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_RecTofTrackMap.clear();
  for (std::map<const TObject*, const  RecTofTrack*>::iterator iter = m_rootRecTofTrackMap.begin();
      iter != m_rootRecTofTrackMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootRecTofTrackMap.clear(); 
 
  for (std::map<const RecMucTrack*, TRef>::iterator iter = m_RecMucTrackMap.begin();
      iter != m_RecMucTrackMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_RecMucTrackMap.clear();
  for (std::map<const TObject*, const  RecMucTrack*>::iterator iter = m_rootRecMucTrackMap.begin();
      iter != m_rootRecMucTrackMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootRecMucTrackMap.clear(); 
  
  for (std::map<const RecMdcDedx*, TRef>::iterator iter = m_recMdcDedxMap.begin();
      iter != m_recMdcDedxMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_recMdcDedxMap.clear();
  for (std::map<const TObject*, const  RecMdcDedx*>::iterator iter =  m_rootRecMdcDedxMap.begin();
      iter !=  m_rootRecMdcDedxMap.end(); iter++) {
    delete (*iter).first;
  }
   m_rootRecMdcDedxMap.clear();
 
 
  for (std::map<const RecMdcDedxHit*, TRef>::iterator iter = m_recMdcDedxHitMap.begin();
      iter != m_recMdcDedxHitMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_recMdcDedxHitMap.clear();
  for (std::map<const TObject*, const  RecMdcDedxHit*>::iterator iter =  m_rootRecMdcDedxHitMap.begin();
      iter !=  m_rootRecMdcDedxHitMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootRecMdcDedxHitMap.clear();
 
  for (std::map<const RecMdcKalTrack*, TRef>::iterator iter = m_recMdcKalTrackMap.begin();
      iter != m_recMdcKalTrackMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_recMdcKalTrackMap.clear();
  for (std::map<const TObject*, const  RecMdcKalTrack*>::iterator iter = m_rootRecMdcKalTrackMap.begin();
      iter != m_rootRecMdcKalTrackMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootRecMdcKalTrackMap.clear(); 
 
 
  for (std::map<const RecMdcKalHelixSeg*, TRef>::iterator iter = m_recMdcKalHelixSegMap.begin();
      iter != m_recMdcKalHelixSegMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_recMdcKalHelixSegMap.clear();
  for (std::map<const TObject*, const  RecMdcKalHelixSeg*>::iterator iter = m_rootRecMdcKalHelixSegMap.begin();
      iter != m_rootRecMdcKalHelixSegMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootRecMdcKalHelixSegMap.clear(); 
 
  for (std::map<const RecCgemDedx*, TRef>::iterator iter = m_recCgemDedxMap.begin();
      iter != m_recCgemDedxMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_recCgemDedxMap.clear();
  for (std::map<const TObject*, const  RecCgemDedx*>::iterator iter =  m_rootRecCgemDedxMap.begin();
      iter !=  m_rootRecCgemDedxMap.end(); iter++) {
    delete (*iter).first;
  }
   m_rootRecCgemDedxMap.clear();
 
 
  for (std::map<const RecCgemDedxHit*, TRef>::iterator iter = m_recCgemDedxHitMap.begin();
      iter != m_recCgemDedxHitMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_recCgemDedxHitMap.clear();
  for (std::map<const TObject*, const  RecCgemDedxHit*>::iterator iter =  m_rootRecCgemDedxHitMap.begin();
      iter !=  m_rootRecCgemDedxHitMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootRecCgemDedxHitMap.clear();
 
  for (std::map<const RecCgemKalTrack*, TRef>::iterator iter = m_recCgemKalTrackMap.begin();
      iter != m_recCgemKalTrackMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_recCgemKalTrackMap.clear();
  for (std::map<const TObject*, const  RecCgemKalTrack*>::iterator iter = m_rootRecCgemKalTrackMap.begin();
      iter != m_rootRecCgemKalTrackMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootRecCgemKalTrackMap.clear(); 
 
 
  for (std::map<const RecCgemKalHelixSeg*, TRef>::iterator iter = m_recCgemKalHelixSegMap.begin();
      iter != m_recCgemKalHelixSegMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_recCgemKalHelixSegMap.clear();
  for (std::map<const TObject*, const  RecCgemKalHelixSeg*>::iterator iter = m_rootRecCgemKalHelixSegMap.begin();
      iter != m_rootRecCgemKalHelixSegMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootRecCgemKalHelixSegMap.clear(); 
 
  // RecZddChannel
  for (std::map<const RecZddChannel*, TRef>::iterator iter = m_recZddChannelMap.begin();
      iter != m_recZddChannelMap.end(); ++iter) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_recZddChannelMap.clear();
  for (std::map<const TObject*, const  RecZddChannel*>::iterator iter = m_rootRecZddChannelMap.begin();
      iter != m_rootRecZddChannelMap.end(); ++iter) {
    delete (*iter).first;
  }
  m_rootRecZddChannelMap.clear();
 
//Estime
    
  for (std::map<const RecEsTime*, TRef>::iterator iter = m_RecEvTimeMap.begin();
      iter != m_RecEvTimeMap.end(); iter++) {
    delete (*iter).second.GetObject(); 
    delete (*iter).first;
  } 
  m_RecEvTimeMap.clear();
  for (std::map<const TObject*, const  RecEsTime*>::iterator iter = m_rootRecEvTimeMap.begin();
      iter != m_rootRecEvTimeMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootRecEvTimeMap.clear();
 
  // for event after EventAssembly
  for (std::map<const EvtRecTrack*, TRef>::iterator iter = m_EvtRecTrackMap.begin();
    iter != m_EvtRecTrackMap.end(); iter++ ) {
     delete (*iter).second.GetObject();
     delete (*iter).first;
  }
  m_EvtRecTrackMap.clear();
  for (std::map<const TObject*, const EvtRecTrack*>::iterator iter = m_rootEvtRecTrackMap.begin();
    iter != m_rootEvtRecTrackMap.end(); iter++) {
     delete iter->first;
  }
  m_rootEvtRecTrackMap.clear();
 
  // EvtRecVeeVertexCol
  for (std::map<const EvtRecVeeVertex*, TRef>::iterator iter = m_evtRecVeeVertexMap.begin();
      iter != m_evtRecVeeVertexMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_evtRecVeeVertexMap.clear();
  for (std::map<const TObject*, const  EvtRecVeeVertex*>::iterator iter = m_rootEvtRecVeeVertexMap.begin();
      iter != m_rootEvtRecVeeVertexMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootEvtRecVeeVertexMap.clear();
 
  //EvtRecPi0Col
  for (std::map<const EvtRecPi0*, TRef>::iterator iter = m_evtRecPi0Map.begin();
      iter != m_evtRecPi0Map.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_evtRecPi0Map.clear();
  for (std::map<const TObject*, const  EvtRecPi0*>::iterator iter = m_rootEvtRecPi0Map.begin();
      iter != m_rootEvtRecPi0Map.end(); iter++) {
    delete (*iter).first;
  }
  m_rootEvtRecPi0Map.clear();
 
 
  //EvtRecEtaToGGCol
  for (std::map<const EvtRecEtaToGG*, TRef>::iterator iter = m_evtRecEtaToGGMap.begin();
      iter != m_evtRecEtaToGGMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_evtRecEtaToGGMap.clear();
  for (std::map<const TObject*, const  EvtRecEtaToGG*>::iterator iter = m_rootEvtRecEtaToGGMap.begin();
      iter != m_rootEvtRecEtaToGGMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootEvtRecEtaToGGMap.clear();
 
  
 
  // EvtRecDTagCol
  for (std::map<const EvtRecDTag*, TRef>::iterator iter = m_evtRecDTagMap.begin();
      iter != m_evtRecDTagMap.end(); iter++) {
    delete (*iter).second.GetObject();
    delete (*iter).first;
  }
  m_evtRecDTagMap.clear();
  for (std::map<const TObject*, const  EvtRecDTag*>::iterator iter = m_rootEvtRecDTagMap.begin();
      iter != m_rootEvtRecDTagMap.end(); iter++) {
    delete (*iter).first;
  }
  m_rootEvtRecDTagMap.clear();
 
}

Referenced by RootCnvSvc::commitOutput(), EventCnv::createObj(), and EventWriter::execute().

Member Data Documentation

m_cgemDedxMap

std::map< const DstCgemDedx *, TRef > commonData::m_cgemDedxMap

static

Definition at line 185 of file commonData.h.

Referenced by clear().

m_cgemDigiMap

std::map< const CgemDigi *, TRef > commonData::m_cgemDigiMap

static

Definition at line 141 of file commonData.h.

Referenced by clear().

m_cgemKalTrackMap

std::map< const DstCgemKalTrack *, TRef > commonData::m_cgemKalTrackMap

static

Definition at line 193 of file commonData.h.

Referenced by clear().

m_cgemMcHitMap

std::map< const CgemMcHit *, TRef > commonData::m_cgemMcHitMap

static

Definition at line 204 of file commonData.h.

Referenced by clear().

m_cgemSegmentMap

std::map< const DstCgemSegment *, TRef > commonData::m_cgemSegmentMap

static

Definition at line 174 of file commonData.h.

Referenced by clear().

m_cgemTrackMap

std::map< const DstCgemTrack *, TRef > commonData::m_cgemTrackMap

static

Definition at line 171 of file commonData.h.

Referenced by clear().

m_dstEvt

TDstEvent * commonData::m_dstEvt = NULL

static

Provide access to the ROOT event pointers.

Definition at line 164 of file commonData.h.

Referenced by clear(), DstCnv::DataObjectToTObject(), and EventWriter::execute().

m_dstHltInfMap

std::map< const DstHltInf *, TRef > commonData::m_dstHltInfMap

static

Definition at line 231 of file commonData.h.

Referenced by clear().

m_emcDigiMap

std::map< const EmcDigi *, TRef > commonData::m_emcDigiMap

static

Definition at line 151 of file commonData.h.

Referenced by clear().

m_emcMcHitMap

std::map< const EmcMcHit *, TRef > commonData::m_emcMcHitMap

static

Definition at line 199 of file commonData.h.

Referenced by clear().

m_emcShowerMap

std::map< const DstEmcShower *, TRef > commonData::m_emcShowerMap

static

Definition at line 166 of file commonData.h.

Referenced by clear().

m_EvtHeader

TEvtHeader * commonData::m_EvtHeader = NULL

static

Definition at line 135 of file commonData.h.

Referenced by clear(), EvtHeaderCnv::DataObjectToTObject(), and EventWriter::execute().

m_EvtNavigator

TEvtNavigator * commonData::m_EvtNavigator = NULL

static

Definition at line 137 of file commonData.h.

Referenced by clear(), EvtNavigatorCnv::DataObjectToTObject(), and EventWriter::execute().

m_evtRecDTagMap

std::map< const EvtRecDTag *, TRef > commonData::m_evtRecDTagMap

static

Definition at line 322 of file commonData.h.

Referenced by clear().

m_evtRecEtaToGGMap

std::map< const EvtRecEtaToGG *, TRef > commonData::m_evtRecEtaToGGMap

static

Definition at line 319 of file commonData.h.

Referenced by clear().

m_evtRecObject

TEvtRecObject * commonData::m_evtRecObject = NULL

static

Definition at line 326 of file commonData.h.

Referenced by clear(), EvtRecCnv::DataObjectToTObject(), and EventWriter::execute().

m_evtRecPi0Map

std::map< const EvtRecPi0 *, TRef > commonData::m_evtRecPi0Map

static

Definition at line 316 of file commonData.h.

Referenced by clear().

m_EvtRecTrackMap

std::map< const EvtRecTrack *, TRef > commonData::m_EvtRecTrackMap

static

Definition at line 328 of file commonData.h.

Referenced by clear().

m_evtRecVeeVertexMap

std::map< const EvtRecVeeVertex *, TRef > commonData::m_evtRecVeeVertexMap

static

Definition at line 313 of file commonData.h.

Referenced by clear().

m_extTrackMap

std::map< const DstExtTrack *, TRef > commonData::m_extTrackMap

static

Definition at line 188 of file commonData.h.

Referenced by clear().

m_hltEvt

THltEvent * commonData::m_hltEvt = NULL

static

Provide access to the ROOT event pointers.

Definition at line 226 of file commonData.h.

Referenced by clear(), HltCnv::DataObjectToTObject(), and EventWriter::execute().

m_hltInfMap

std::map< const HltInf *, TRef > commonData::m_hltInfMap

static

Definition at line 229 of file commonData.h.

Referenced by clear().

m_hltRawMap

std::map< const HltRaw *, TRef > commonData::m_hltRawMap

static

Definition at line 227 of file commonData.h.

Referenced by clear().

m_lumiDigiMap

std::map< const LumiDigi *, TRef > commonData::m_lumiDigiMap

static

Definition at line 160 of file commonData.h.

Referenced by clear().

m_mcEvt

TMcEvent * commonData::m_mcEvt = NULL

static

Provide access to the ROOT event pointers.

Definition at line 197 of file commonData.h.

Referenced by clear(), McCnv::DataObjectToTObject(), and EventWriter::execute().

m_mcParticleMap

std::map< const McParticle *, TRef > commonData::m_mcParticleMap

static

Definition at line 213 of file commonData.h.

Referenced by clear().

m_mdcDedxMap

std::map< const DstMdcDedx *, TRef > commonData::m_mdcDedxMap

static

Definition at line 183 of file commonData.h.

Referenced by clear().

m_mdcDigiMap

std::map< const MdcDigi *, TRef > commonData::m_mdcDigiMap

static

Create a set of maps between Digi data in the TDS and the TRefs in the ROOT file.

Definition at line 140 of file commonData.h.

Referenced by clear().

m_mdcKalTrackMap

std::map< const DstMdcKalTrack *, TRef > commonData::m_mdcKalTrackMap

static

Definition at line 191 of file commonData.h.

Referenced by clear().

m_mdcMcHitMap

std::map< const MdcMcHit *, TRef > commonData::m_mdcMcHitMap

static

Definition at line 202 of file commonData.h.

Referenced by clear().

m_mdcTrackMap

std::map< const DstMdcTrack *, TRef > commonData::m_mdcTrackMap

static

Definition at line 169 of file commonData.h.

Referenced by clear().

m_mucDigiMap

std::map< const MucDigi *, TRef > commonData::m_mucDigiMap

static

Definition at line 157 of file commonData.h.

Referenced by clear().

m_mucMcHitMap

std::map< const MucMcHit *, TRef > commonData::m_mucMcHitMap

static

Definition at line 210 of file commonData.h.

Referenced by clear().

m_mucTrackMap

std::map< const DstMucTrack *, TRef > commonData::m_mucTrackMap

static

Definition at line 177 of file commonData.h.

Referenced by clear().

m_recCgemClusterMap

std::map< const RecCgemCluster *, TRef > commonData::m_recCgemClusterMap

static

Definition at line 252 of file commonData.h.

Referenced by clear().

m_recCgemDedxHitMap

std::map< const RecCgemDedxHit *, TRef > commonData::m_recCgemDedxHitMap

static

Definition at line 284 of file commonData.h.

Referenced by clear().

m_recCgemDedxMap

std::map< const RecCgemDedx *, TRef > commonData::m_recCgemDedxMap

static

Definition at line 281 of file commonData.h.

Referenced by clear().

m_recCgemHitMap

std::map< const RecCgemHit *, TRef > commonData::m_recCgemHitMap

static

Definition at line 249 of file commonData.h.

Referenced by clear().

m_recCgemKalHelixSegMap

std::map< const RecCgemKalHelixSeg *, TRef > commonData::m_recCgemKalHelixSegMap

static

Definition at line 304 of file commonData.h.

Referenced by clear().

m_recCgemKalTrackMap

std::map< const RecCgemKalTrack *, TRef > commonData::m_recCgemKalTrackMap

static

Definition at line 301 of file commonData.h.

Referenced by clear().

m_recCgemSegmentMap

std::map< const RecCgemSegment *, TRef > commonData::m_recCgemSegmentMap

static

Definition at line 246 of file commonData.h.

Referenced by clear().

m_recCgemTrackMap

std::map< const RecCgemTrack *, TRef > commonData::m_recCgemTrackMap

static

Definition at line 243 of file commonData.h.

Referenced by clear().

m_recEmcClusterMap

std::map< const RecEmcCluster *, TRef > commonData::m_recEmcClusterMap

static

Definition at line 266 of file commonData.h.

Referenced by clear().

m_recEmcHitMap

std::map< const RecEmcHit *, TRef > commonData::m_recEmcHitMap

static

Definition at line 263 of file commonData.h.

Referenced by clear().

m_recEmcShowerMap

std::map< const RecEmcShower *, TRef > commonData::m_recEmcShowerMap

static

Definition at line 269 of file commonData.h.

Referenced by clear().

m_recEvt

TDigiEvent * commonData::m_recEvt = NULL

static

Provide access to the ROOT event pointers.

Definition at line 149 of file commonData.h.

Referenced by clear(), DigiCnv::DataObjectToTObject(), and EventWriter::execute().

m_RecEvTimeMap

std::map< const RecEsTime *, TRef > commonData::m_RecEvTimeMap

static

Definition at line 307 of file commonData.h.

Referenced by clear().

m_recMdcDedxHitMap

std::map< const RecMdcDedxHit *, TRef > commonData::m_recMdcDedxHitMap

static

Definition at line 278 of file commonData.h.

Referenced by clear().

m_recMdcDedxMap

std::map< const RecMdcDedx *, TRef > commonData::m_recMdcDedxMap

static

Definition at line 275 of file commonData.h.

Referenced by clear().

m_recMdcHitMap

std::map< const RecMdcHit *, TRef > commonData::m_recMdcHitMap

static

Definition at line 240 of file commonData.h.

Referenced by clear().

m_recMdcKalHelixSegMap

std::map< const RecMdcKalHelixSeg *, TRef > commonData::m_recMdcKalHelixSegMap

static

Definition at line 298 of file commonData.h.

Referenced by clear().

m_recMdcKalTrackMap

std::map< const RecMdcKalTrack *, TRef > commonData::m_recMdcKalTrackMap

static

Definition at line 295 of file commonData.h.

Referenced by clear().

m_recMdcTrackMap

std::map< const RecMdcTrack *, TRef > commonData::m_recMdcTrackMap

static

Definition at line 237 of file commonData.h.

Referenced by clear().

m_RecMucTrackMap

std::map< const RecMucTrack *, TRef > commonData::m_RecMucTrackMap

static

Definition at line 272 of file commonData.h.

Referenced by clear().

m_RecTofTrackMap

std::map< const RecTofTrack *, TRef > commonData::m_RecTofTrackMap

static

Definition at line 260 of file commonData.h.

Referenced by clear().

m_rectrackEvt

TRecTrackEvent * commonData::m_rectrackEvt = NULL

static

Provide access to the ROOT event pointers.

Definition at line 235 of file commonData.h.

Referenced by clear(), RecTrackCnv::DataObjectToTObject(), and EventWriter::execute().

m_recZddChannelMap

std::map< const RecZddChannel *, TRef > commonData::m_recZddChannelMap

static

Definition at line 310 of file commonData.h.

Referenced by clear().

m_rootCgemDedxMap

std::map< const TObject *, const DstCgemDedx * > commonData::m_rootCgemDedxMap

static

Definition at line 186 of file commonData.h.

Referenced by clear(), and CgemDedxCnv::TObjectToDataObject().

m_rootCgemDigiMap

std::map< const TObject *, const CgemDigi * > commonData::m_rootCgemDigiMap

static

Definition at line 145 of file commonData.h.

Referenced by clear(), and CgemDigiCnv::TObjectToDataObject().

m_rootCgemKalTrackMap

std::map< const TObject *, const DstCgemKalTrack * > commonData::m_rootCgemKalTrackMap

static

Definition at line 194 of file commonData.h.

Referenced by clear(), and CgemKalTrackCnv::TObjectToDataObject().

m_rootCgemMcHitMap

std::map< const TObject *, const CgemMcHit * > commonData::m_rootCgemMcHitMap

static

Definition at line 205 of file commonData.h.

Referenced by clear(), and CgemMcHitCnv::TObjectToDataObject().

m_rootCgemSegmentMap

std::map< const TObject *, const DstCgemSegment * > commonData::m_rootCgemSegmentMap

static

Definition at line 175 of file commonData.h.

Referenced by clear(), and CgemSegmentCnv::TObjectToDataObject().

m_rootCgemTrackMap

std::map< const TObject *, const DstCgemTrack * > commonData::m_rootCgemTrackMap

static

Definition at line 172 of file commonData.h.

Referenced by clear(), and CgemTrackCnv::TObjectToDataObject().

m_rootDstHltInfMap

std::map< const TObject *, const DstHltInf * > commonData::m_rootDstHltInfMap

static

Definition at line 232 of file commonData.h.

Referenced by clear().

m_rootEmcDigiMap

std::map< const TObject *, const EmcDigi * > commonData::m_rootEmcDigiMap

static

Definition at line 152 of file commonData.h.

Referenced by clear(), and EmcDigiCnv::TObjectToDataObject().

m_rootEmcMcHitMap

std::map< const TObject *, const EmcMcHit * > commonData::m_rootEmcMcHitMap

static

Definition at line 200 of file commonData.h.

Referenced by clear(), and EmcMcHitCnv::TObjectToDataObject().

m_rootEmcShowerMap

std::map< const TObject *, const DstEmcShower * > commonData::m_rootEmcShowerMap

static

Definition at line 167 of file commonData.h.

Referenced by clear(), and EmcTrackCnv::TObjectToDataObject().

m_rootEvtRecDTagMap

std::map< const TObject *, const EvtRecDTag * > commonData::m_rootEvtRecDTagMap

static

Definition at line 323 of file commonData.h.

Referenced by clear(), and EvtRecDTagCnv::TObjectToDataObject().

m_rootEvtRecEtaToGGMap

std::map< const TObject *, const EvtRecEtaToGG * > commonData::m_rootEvtRecEtaToGGMap

static

Definition at line 320 of file commonData.h.

Referenced by clear(), and EvtRecEtaToGGCnv::TObjectToDataObject().

m_rootEvtRecPi0Map

std::map< const TObject *, const EvtRecPi0 * > commonData::m_rootEvtRecPi0Map

static

Definition at line 317 of file commonData.h.

Referenced by clear(), and EvtRecPi0Cnv::TObjectToDataObject().

m_rootEvtRecTrackMap

std::map< const TObject *, const EvtRecTrack * > commonData::m_rootEvtRecTrackMap

static

Definition at line 329 of file commonData.h.

Referenced by clear(), and EvtRecTrackCnv::TObjectToDataObject().

m_rootEvtRecVeeVertexMap

std::map< const TObject *, const EvtRecVeeVertex * > commonData::m_rootEvtRecVeeVertexMap

static

Definition at line 314 of file commonData.h.

Referenced by clear(), and EvtRecVeeVertexCnv::TObjectToDataObject().

m_rootExtTrackMap

std::map< const TObject *, const DstExtTrack * > commonData::m_rootExtTrackMap

static

Definition at line 189 of file commonData.h.

Referenced by clear(), ExtTrackCnv::TObjectToDataObject(), and RecExtTrackCnv::TObjectToDataObject().

m_rootHltInfMap

std::map< const TObject *, const HltInf * > commonData::m_rootHltInfMap

static

Definition at line 230 of file commonData.h.

Referenced by clear().

m_rootHltRawMap

std::map< const TObject *, const HltRaw * > commonData::m_rootHltRawMap

static

Definition at line 228 of file commonData.h.

Referenced by clear(), and HltRawCnv::TObjectToDataObject().

m_rootLumiDigiMap

std::map< const TObject *, const LumiDigi * > commonData::m_rootLumiDigiMap

static

Definition at line 161 of file commonData.h.

Referenced by clear(), and LumiDigiCnv::TObjectToDataObject().

m_rootMcParticleMap

std::map< const TObject *, const McParticle * > commonData::m_rootMcParticleMap

static

Definition at line 214 of file commonData.h.

Referenced by clear(), and McParticleCnv::TObjectToDataObject().

m_rootMdcDedxMap

std::map< const TObject *, const DstMdcDedx * > commonData::m_rootMdcDedxMap

static

Definition at line 184 of file commonData.h.

Referenced by clear(), and MdcDedxCnv::TObjectToDataObject().

m_rootMdcDigiMap

std::map< const TObject *, const MdcDigi * > commonData::m_rootMdcDigiMap

static

Create a set of maps between ROOT Digi objects and TDS Digi data.

Definition at line 144 of file commonData.h.

Referenced by clear(), and MdcDigiCnv::TObjectToDataObject().

m_rootMdcKalTrackMap

std::map< const TObject *, const DstMdcKalTrack * > commonData::m_rootMdcKalTrackMap

static

Definition at line 192 of file commonData.h.

Referenced by clear(), and MdcKalTrackCnv::TObjectToDataObject().

m_rootMdcMcHitMap

std::map< const TObject *, const MdcMcHit * > commonData::m_rootMdcMcHitMap

static

Definition at line 203 of file commonData.h.

Referenced by clear(), and MdcMcHitCnv::TObjectToDataObject().

m_rootMdcTrackMap

std::map< const TObject *, const DstMdcTrack * > commonData::m_rootMdcTrackMap

static

Definition at line 170 of file commonData.h.

Referenced by clear(), and MdcTrackCnv::TObjectToDataObject().

m_rootMucDigiMap

std::map< const TObject *, const MucDigi * > commonData::m_rootMucDigiMap

static

Definition at line 158 of file commonData.h.

Referenced by clear(), and MucDigiCnv::TObjectToDataObject().

m_rootMucMcHitMap

std::map< const TObject *, const MucMcHit * > commonData::m_rootMucMcHitMap

static

Definition at line 211 of file commonData.h.

Referenced by clear(), and MucMcHitCnv::TObjectToDataObject().

m_rootMucTrackMap

std::map< const TObject *, const DstMucTrack * > commonData::m_rootMucTrackMap

static

Definition at line 178 of file commonData.h.

Referenced by clear(), and MucTrackCnv::TObjectToDataObject().

m_rootRecCgemClusterMap

std::map< const TObject *, const RecCgemCluster * > commonData::m_rootRecCgemClusterMap

static

Definition at line 253 of file commonData.h.

Referenced by clear(), and RecCgemClusterCnv::TObjectToDataObject().

m_rootRecCgemDedxHitMap

std::map< const TObject *, const RecCgemDedxHit * > commonData::m_rootRecCgemDedxHitMap

static

Definition at line 285 of file commonData.h.

Referenced by clear(), and RecCgemDedxHitCnv::TObjectToDataObject().

m_rootRecCgemDedxMap

std::map< const TObject *, const RecCgemDedx * > commonData::m_rootRecCgemDedxMap

static

Definition at line 282 of file commonData.h.

Referenced by clear(), and RecCgemDedxCnv::TObjectToDataObject().

m_rootRecCgemHitMap

std::map< const TObject *, const RecCgemHit * > commonData::m_rootRecCgemHitMap

static

Definition at line 250 of file commonData.h.

Referenced by clear(), and RecCgemHitCnv::TObjectToDataObject().

m_rootRecCgemKalHelixSegMap

std::map< const TObject *, const RecCgemKalHelixSeg * > commonData::m_rootRecCgemKalHelixSegMap

static

Definition at line 305 of file commonData.h.

Referenced by clear(), and RecCgemKalHelixSegCnv::TObjectToDataObject().

m_rootRecCgemKalTrackMap

std::map< const TObject *, const RecCgemKalTrack * > commonData::m_rootRecCgemKalTrackMap

static

Definition at line 302 of file commonData.h.

Referenced by clear(), and RecCgemKalTrackCnv::TObjectToDataObject().

m_rootRecCgemSegmentMap

std::map< const TObject *, const RecCgemSegment * > commonData::m_rootRecCgemSegmentMap

static

Definition at line 247 of file commonData.h.

Referenced by clear(), and RecCgemSegmentCnv::TObjectToDataObject().

m_rootRecCgemTrackMap

std::map< const TObject *, const RecCgemTrack * > commonData::m_rootRecCgemTrackMap

static

Definition at line 244 of file commonData.h.

Referenced by clear(), and RecCgemTrackCnv::TObjectToDataObject().

m_rootRecEmcClusterMap

std::map< const TObject *, const RecEmcCluster * > commonData::m_rootRecEmcClusterMap

static

Definition at line 267 of file commonData.h.

Referenced by clear(), and RecEmcClusterCnv::TObjectToDataObject().

m_rootRecEmcHitMap

std::map< const TObject *, const RecEmcHit * > commonData::m_rootRecEmcHitMap

static

Definition at line 264 of file commonData.h.

Referenced by clear(), and RecEmcHitCnv::TObjectToDataObject().

m_rootRecEmcShowerMap

std::map< const TObject *, const RecEmcShower * > commonData::m_rootRecEmcShowerMap

static

Definition at line 270 of file commonData.h.

Referenced by clear(), and RecEmcShowerCnv::TObjectToDataObject().

m_rootRecEvTimeMap

std::map< const TObject *, const RecEsTime * > commonData::m_rootRecEvTimeMap

static

Definition at line 308 of file commonData.h.

Referenced by clear(), and RecEvTimeCnv::TObjectToDataObject().

m_rootRecMdcDedxHitMap

std::map< const TObject *, const RecMdcDedxHit * > commonData::m_rootRecMdcDedxHitMap

static

Definition at line 279 of file commonData.h.

Referenced by clear(), and RecMdcDedxHitCnv::TObjectToDataObject().

m_rootRecMdcDedxMap

std::map< const TObject *, const RecMdcDedx * > commonData::m_rootRecMdcDedxMap

static

Definition at line 276 of file commonData.h.

Referenced by clear(), and RecMdcDedxCnv::TObjectToDataObject().

m_rootRecMdcHitMap

std::map< const TObject *, const RecMdcHit * > commonData::m_rootRecMdcHitMap

static

Definition at line 241 of file commonData.h.

Referenced by clear(), and RecMdcHitCnv::TObjectToDataObject().

m_rootRecMdcKalHelixSegMap

std::map< const TObject *, const RecMdcKalHelixSeg * > commonData::m_rootRecMdcKalHelixSegMap

static

Definition at line 299 of file commonData.h.

Referenced by clear(), and RecMdcKalHelixSegCnv::TObjectToDataObject().

m_rootRecMdcKalTrackMap

std::map< const TObject *, const RecMdcKalTrack * > commonData::m_rootRecMdcKalTrackMap

static

Definition at line 296 of file commonData.h.

Referenced by clear(), and RecMdcKalTrackCnv::TObjectToDataObject().

m_rootRecMdcTrackMap

std::map< const TObject *, const RecMdcTrack * > commonData::m_rootRecMdcTrackMap

static

Definition at line 238 of file commonData.h.

Referenced by clear(), and RecMdcTrackCnv::TObjectToDataObject().

m_rootRecMucTrackMap

std::map< const TObject *, const RecMucTrack * > commonData::m_rootRecMucTrackMap

static

Definition at line 273 of file commonData.h.

Referenced by clear(), and RecMucTrackCnv::TObjectToDataObject().

m_rootRecTofTrackMap

std::map< const TObject *, const RecTofTrack * > commonData::m_rootRecTofTrackMap

static

Definition at line 261 of file commonData.h.

Referenced by clear(), and RecTofTrackCnv::TObjectToDataObject().

m_rootRecZddChannelMap

std::map< const TObject *, const RecZddChannel * > commonData::m_rootRecZddChannelMap

static

Definition at line 311 of file commonData.h.

Referenced by clear(), and RecZddChannelCnv::TObjectToDataObject().

m_rootTofDigiMap

std::map< const TObject *, const TofDigi * > commonData::m_rootTofDigiMap

static

Definition at line 155 of file commonData.h.

Referenced by clear(), and TofDigiCnv::TObjectToDataObject().

m_rootTofMcHitMap

std::map< const TObject *, const TofMcHit * > commonData::m_rootTofMcHitMap

static

Definition at line 208 of file commonData.h.

Referenced by clear(), and TofMcHitCnv::TObjectToDataObject().

m_rootTofTrackMap

std::map< const TObject *, const DstTofTrack * > commonData::m_rootTofTrackMap

static

Definition at line 181 of file commonData.h.

Referenced by clear(), and TofTrackCnv::TObjectToDataObject().

m_rootTrigDataMap

std::map< const TObject *, const TrigData * > commonData::m_rootTrigDataMap

static

Definition at line 223 of file commonData.h.

Referenced by clear().

m_tofDigiMap

std::map< const TofDigi *, TRef > commonData::m_tofDigiMap

static

Definition at line 154 of file commonData.h.

Referenced by clear().

m_tofMcHitMap

std::map< const TofMcHit *, TRef > commonData::m_tofMcHitMap

static

Definition at line 207 of file commonData.h.

Referenced by clear().

m_tofTrackMap

std::map< const DstTofTrack *, TRef > commonData::m_tofTrackMap

static

Definition at line 180 of file commonData.h.

Referenced by clear().

m_trigDataMap

std::map< const TrigData *, TRef > commonData::m_trigDataMap

static

Definition at line 222 of file commonData.h.

Referenced by clear().

m_trigEvt

TTrigEvent * commonData::m_trigEvt = NULL

static

Provide access to the ROOT event pointers.

Definition at line 220 of file commonData.h.

Referenced by clear(), TrigCnv::DataObjectToTObject(), and EventWriter::execute().

---

The documentation for this class was generated from the following files:

• commonData.h
• commonData.cxx