#include <commonData.h>

Public Member Functions
	commonData ()
	~commonData ()
void	clear ()
	commonData ()
	~commonData ()
void	clear ()
	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 TObject , const MdcDigi >	m_rootMdcDigiMap
	Create a set of maps between ROOT Digi objects and TDS Digi data.
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 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 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 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 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 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 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 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 100 of file Event/RootCnvSvc/include/RootCnvSvc/commonData.h.

Constructor & Destructor Documentation

◆ commonData() [1/3]

commonData::commonData ( )

inline

Definition at line 102 of file Event/RootCnvSvc/include/RootCnvSvc/commonData.h.

102{};

◆ ~commonData() [1/3]

commonData::~commonData ( )

inline

Definition at line 103 of file Event/RootCnvSvc/include/RootCnvSvc/commonData.h.

103{};

◆ commonData() [2/3]

commonData::commonData ( )

inline

Definition at line 102 of file InstallArea/x86_64-el9-gcc13-dbg/include/RootCnvSvc/commonData.h.

102{};

◆ ~commonData() [2/3]

commonData::~commonData ( )

inline

Definition at line 103 of file InstallArea/x86_64-el9-gcc13-dbg/include/RootCnvSvc/commonData.h.

103{};

◆ commonData() [3/3]

commonData::commonData ( )

inline

Definition at line 102 of file InstallArea/x86_64-el9-gcc13-opt/include/RootCnvSvc/commonData.h.

102{};

◆ ~commonData() [3/3]

commonData::~commonData ( )

inline

Definition at line 103 of file InstallArea/x86_64-el9-gcc13-opt/include/RootCnvSvc/commonData.h.

103{};

Member Function Documentation

◆ clear() [1/3]

void commonData::clear ( )

Definition at line 146 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 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 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 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 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();
 
  // 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();
 
  // 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();
}