Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

commonData Class Reference

#include <commonData.h>

List of all members.

Public Member Functions

void clear ()
void clear ()
 commonData ()
 commonData ()
 ~commonData ()
 ~commonData ()

Static Public Attributes

TDstEvent * m_dstEvt
 Provide access to the ROOT event pointers.
TDstEvent * m_dstEvt = NULL
 Provide access to the ROOT event pointers.
std::map< const DstHltInf *,
TRef > 		m_dstHltInfMap
std::map< const DstHltInf *,
TRef > 		m_dstHltInfMap
std::map< const EmcDigi *,
TRef > 		m_emcDigiMap
std::map< const EmcDigi *,
TRef > 		m_emcDigiMap
std::map< const EmcMcHit *,
TRef > 		m_emcMcHitMap
std::map< const EmcMcHit *,
TRef > 		m_emcMcHitMap
std::map< const DstEmcShower *,
TRef > 		m_emcShowerMap
std::map< const DstEmcShower *,
TRef > 		m_emcShowerMap
TEvtHeader * m_EvtHeader
TEvtHeader * m_EvtHeader = NULL
std::map< const EvtRecDTag *,
TRef > 		m_evtRecDTagMap
std::map< const EvtRecDTag *,
TRef > 		m_evtRecDTagMap
std::map< const EvtRecEtaToGG *,
TRef > 		m_evtRecEtaToGGMap
std::map< const EvtRecEtaToGG *,
TRef > 		m_evtRecEtaToGGMap
TEvtRecObject * m_evtRecObject
TEvtRecObject * m_evtRecObject = NULL
std::map< const EvtRecPi0 *,
TRef > 		m_evtRecPi0Map
std::map< const EvtRecPi0 *,
TRef > 		m_evtRecPi0Map
std::map< const EvtRecTrack *,
TRef > 		m_EvtRecTrackMap
std::map< const EvtRecTrack *,
TRef > 		m_EvtRecTrackMap
std::map< const EvtRecVeeVertex *,
TRef > 		m_evtRecVeeVertexMap
std::map< const EvtRecVeeVertex *,
TRef > 		m_evtRecVeeVertexMap
std::map< const DstExtTrack *,
TRef > 		m_extTrackMap
std::map< const DstExtTrack *,
TRef > 		m_extTrackMap
THltEvent * m_hltEvt
 Provide access to the ROOT event pointers.
THltEvent * m_hltEvt = NULL
 Provide access to the ROOT event pointers.
std::map< const HltInf *,
TRef > 		m_hltInfMap
std::map< const HltInf *,
TRef > 		m_hltInfMap
std::map< const HltRaw *,
TRef > 		m_hltRawMap
std::map< const HltRaw *,
TRef > 		m_hltRawMap
std::map< const LumiDigi *,
TRef > 		m_lumiDigiMap
std::map< const LumiDigi *,
TRef > 		m_lumiDigiMap
TMcEvent * m_mcEvt
 Provide access to the ROOT event pointers.
TMcEvent * m_mcEvt = NULL
 Provide access to the ROOT event pointers.
std::map< const McParticle *,
TRef > 		m_mcParticleMap
std::map< const McParticle *,
TRef > 		m_mcParticleMap
std::map< const DstMdcDedx *,
TRef > 		m_mdcDedxMap
std::map< const DstMdcDedx *,
TRef > 		m_mdcDedxMap
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.
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.
std::map< const DstMdcKalTrack *,
TRef > 		m_mdcKalTrackMap
std::map< const DstMdcKalTrack *,
TRef > 		m_mdcKalTrackMap
std::map< const MdcMcHit *,
TRef > 		m_mdcMcHitMap
std::map< const MdcMcHit *,
TRef > 		m_mdcMcHitMap
std::map< const DstMdcTrack *,
TRef > 		m_mdcTrackMap
std::map< const DstMdcTrack *,
TRef > 		m_mdcTrackMap
std::map< const MucDigi *,
TRef > 		m_mucDigiMap
std::map< const MucDigi *,
TRef > 		m_mucDigiMap
std::map< const MucMcHit *,
TRef > 		m_mucMcHitMap
std::map< const MucMcHit *,
TRef > 		m_mucMcHitMap
std::map< const DstMucTrack *,
TRef > 		m_mucTrackMap
std::map< const DstMucTrack *,
TRef > 		m_mucTrackMap
std::map< const RecEmcCluster *,
TRef > 		m_recEmcClusterMap
std::map< const RecEmcCluster *,
TRef > 		m_recEmcClusterMap
std::map< const RecEmcHit *,
TRef > 		m_recEmcHitMap
std::map< const RecEmcHit *,
TRef > 		m_recEmcHitMap
std::map< const RecEmcShower *,
TRef > 		m_recEmcShowerMap
std::map< const RecEmcShower *,
TRef > 		m_recEmcShowerMap
TDigiEvent * m_recEvt
 Provide access to the ROOT event pointers.
TDigiEvent * m_recEvt = NULL
 Provide access to the ROOT event pointers.
std::map< const RecEsTime *,
TRef > 		m_RecEvTimeMap
std::map< const RecEsTime *,
TRef > 		m_RecEvTimeMap
std::map< const RecMdcDedxHit *,
TRef > 		m_recMdcDedxHitMap
std::map< const RecMdcDedxHit *,
TRef > 		m_recMdcDedxHitMap
std::map< const RecMdcDedx *,
TRef > 		m_recMdcDedxMap
std::map< const RecMdcDedx *,
TRef > 		m_recMdcDedxMap
std::map< const RecMdcHit *,
TRef > 		m_recMdcHitMap
std::map< const RecMdcHit *,
TRef > 		m_recMdcHitMap
std::map< const RecMdcKalHelixSeg *,
TRef > 		m_recMdcKalHelixSegMap
std::map< const RecMdcKalHelixSeg *,
TRef > 		m_recMdcKalHelixSegMap
std::map< const RecMdcKalTrack *,
TRef > 		m_recMdcKalTrackMap
std::map< const RecMdcKalTrack *,
TRef > 		m_recMdcKalTrackMap
std::map< const RecMdcTrack *,
TRef > 		m_recMdcTrackMap
std::map< const RecMdcTrack *,
TRef > 		m_recMdcTrackMap
std::map< const RecMucTrack *,
TRef > 		m_RecMucTrackMap
std::map< const RecMucTrack *,
TRef > 		m_RecMucTrackMap
std::map< const RecTofTrack *,
TRef > 		m_RecTofTrackMap
std::map< const RecTofTrack *,
TRef > 		m_RecTofTrackMap
TRecTrackEvent * m_rectrackEvt
 Provide access to the ROOT event pointers.
TRecTrackEvent * m_rectrackEvt = NULL
 Provide access to the ROOT event pointers.
std::map< const TObject *,
const DstHltInf * > 		m_rootDstHltInfMap
std::map< const TObject *,
const DstHltInf * > 		m_rootDstHltInfMap
std::map< const TObject *,
const EmcDigi * > 		m_rootEmcDigiMap
std::map< const TObject *,
const EmcDigi * > 		m_rootEmcDigiMap
std::map< const TObject *,
const EmcMcHit * > 		m_rootEmcMcHitMap
std::map< const TObject *,
const EmcMcHit * > 		m_rootEmcMcHitMap
std::map< const TObject *,
const DstEmcShower * > 		m_rootEmcShowerMap
std::map< const TObject *,
const DstEmcShower * > 		m_rootEmcShowerMap
std::map< const TObject *,
const EvtRecDTag * > 		m_rootEvtRecDTagMap
std::map< const TObject *,
const EvtRecDTag * > 		m_rootEvtRecDTagMap
std::map< const TObject *,
const EvtRecEtaToGG * > 		m_rootEvtRecEtaToGGMap
std::map< const TObject *,
const EvtRecEtaToGG * > 		m_rootEvtRecEtaToGGMap
std::map< const TObject *,
const EvtRecPi0 * > 		m_rootEvtRecPi0Map
std::map< const TObject *,
const EvtRecPi0 * > 		m_rootEvtRecPi0Map
std::map< const TObject *,
const EvtRecTrack * > 		m_rootEvtRecTrackMap
std::map< const TObject *,
const EvtRecTrack * > 		m_rootEvtRecTrackMap
std::map< const TObject *,
const EvtRecVeeVertex * > 		m_rootEvtRecVeeVertexMap
std::map< const TObject *,
const EvtRecVeeVertex * > 		m_rootEvtRecVeeVertexMap
std::map< const TObject *,
const DstExtTrack * > 		m_rootExtTrackMap
std::map< const TObject *,
const DstExtTrack * > 		m_rootExtTrackMap
std::map< const TObject *,
const HltInf * > 		m_rootHltInfMap
std::map< const TObject *,
const HltInf * > 		m_rootHltInfMap
std::map< const TObject *,
const HltRaw * > 		m_rootHltRawMap
std::map< const TObject *,
const HltRaw * > 		m_rootHltRawMap
std::map< const TObject *,
const LumiDigi * > 		m_rootLumiDigiMap
std::map< const TObject *,
const LumiDigi * > 		m_rootLumiDigiMap
std::map< const TObject *,
const McParticle * > 		m_rootMcParticleMap
std::map< const TObject *,
const McParticle * > 		m_rootMcParticleMap
std::map< const TObject *,
const DstMdcDedx * > 		m_rootMdcDedxMap
std::map< const TObject *,
const DstMdcDedx * > 		m_rootMdcDedxMap
std::map< const TObject *,
const MdcDigi * > 		m_rootMdcDigiMap
 Create a set of maps between ROOT Digi objects and TDS Digi data.
std::map< const TObject *,
const MdcDigi * > 		m_rootMdcDigiMap
 Create a set of maps between ROOT Digi objects and TDS Digi data.
std::map< const TObject *,
const DstMdcKalTrack * > 		m_rootMdcKalTrackMap
std::map< const TObject *,
const DstMdcKalTrack * > 		m_rootMdcKalTrackMap
std::map< const TObject *,
const MdcMcHit * > 		m_rootMdcMcHitMap
std::map< const TObject *,
const MdcMcHit * > 		m_rootMdcMcHitMap
std::map< const TObject *,
const DstMdcTrack * > 		m_rootMdcTrackMap
std::map< const TObject *,
const DstMdcTrack * > 		m_rootMdcTrackMap
std::map< const TObject *,
const MucDigi * > 		m_rootMucDigiMap
std::map< const TObject *,
const MucDigi * > 		m_rootMucDigiMap
std::map< const TObject *,
const MucMcHit * > 		m_rootMucMcHitMap
std::map< const TObject *,
const MucMcHit * > 		m_rootMucMcHitMap
std::map< const TObject *,
const DstMucTrack * > 		m_rootMucTrackMap
std::map< const TObject *,
const DstMucTrack * > 		m_rootMucTrackMap
std::map< const TObject *,
const RecEmcCluster * > 		m_rootRecEmcClusterMap
std::map< const TObject *,
const RecEmcCluster * > 		m_rootRecEmcClusterMap
std::map< const TObject *,
const RecEmcHit * > 		m_rootRecEmcHitMap
std::map< const TObject *,
const RecEmcHit * > 		m_rootRecEmcHitMap
std::map< const TObject *,
const RecEmcShower * > 		m_rootRecEmcShowerMap
std::map< const TObject *,
const RecEmcShower * > 		m_rootRecEmcShowerMap
std::map< const TObject *,
const RecEsTime * > 		m_rootRecEvTimeMap
std::map< const TObject *,
const RecEsTime * > 		m_rootRecEvTimeMap
std::map< const TObject *,
const RecMdcDedxHit * > 		m_rootRecMdcDedxHitMap
std::map< const TObject *,
const RecMdcDedxHit * > 		m_rootRecMdcDedxHitMap
std::map< const TObject *,
const RecMdcDedx * > 		m_rootRecMdcDedxMap
std::map< const TObject *,
const RecMdcDedx * > 		m_rootRecMdcDedxMap
std::map< const TObject *,
const RecMdcHit * > 		m_rootRecMdcHitMap
std::map< const TObject *,
const RecMdcHit * > 		m_rootRecMdcHitMap
std::map< const TObject *,
const RecMdcKalHelixSeg * > 		m_rootRecMdcKalHelixSegMap
std::map< const TObject *,
const RecMdcKalHelixSeg * > 		m_rootRecMdcKalHelixSegMap
std::map< const TObject *,
const RecMdcKalTrack * > 		m_rootRecMdcKalTrackMap
std::map< const TObject *,
const RecMdcKalTrack * > 		m_rootRecMdcKalTrackMap
std::map< const TObject *,
const RecMdcTrack * > 		m_rootRecMdcTrackMap
std::map< const TObject *,
const RecMdcTrack * > 		m_rootRecMdcTrackMap
std::map< const TObject *,
const RecMucTrack * > 		m_rootRecMucTrackMap
std::map< const TObject *,
const RecMucTrack * > 		m_rootRecMucTrackMap
std::map< const TObject *,
const RecTofTrack * > 		m_rootRecTofTrackMap
std::map< const TObject *,
const RecTofTrack * > 		m_rootRecTofTrackMap
std::map< const TObject *,
const TofDigi * > 		m_rootTofDigiMap
std::map< const TObject *,
const TofDigi * > 		m_rootTofDigiMap
std::map< const TObject *,
const TofMcHit * > 		m_rootTofMcHitMap
std::map< const TObject *,
const TofMcHit * > 		m_rootTofMcHitMap
std::map< const TObject *,
const DstTofTrack * > 		m_rootTofTrackMap
std::map< const TObject *,
const DstTofTrack * > 		m_rootTofTrackMap
std::map< const TObject *,
const TrigData * > 		m_rootTrigDataMap
std::map< const TObject *,
const TrigData * > 		m_rootTrigDataMap
std::map< const TofDigi *,
TRef > 		m_tofDigiMap
std::map< const TofDigi *,
TRef > 		m_tofDigiMap
std::map< const TofMcHit *,
TRef > 		m_tofMcHitMap
std::map< const TofMcHit *,
TRef > 		m_tofMcHitMap
std::map< const DstTofTrack *,
TRef > 		m_tofTrackMap
std::map< const DstTofTrack *,
TRef > 		m_tofTrackMap
std::map< const TrigData *,
TRef > 		m_trigDataMap
std::map< const TrigData *,
TRef > 		m_trigDataMap
TTrigEvent * m_trigEvt
 Provide access to the ROOT event pointers.
TTrigEvent * m_trigEvt = NULL
 Provide access to the ROOT event pointers.

Constructor & Destructor Documentation

commonData::commonData (   )  [inline]
  

00104 {  };

commonData::~commonData (   )  [inline]
  

00105 {  };

commonData::commonData (   )  [inline]
  

00104 {  };

commonData::~commonData (   )  [inline]
  

00105 {  };

Member Function Documentation

void commonData::clear (   ) 
 

void commonData::clear (   ) 
  

00146                        { 
00147 //for digi
00148 
00149   if (m_recEvt != NULL) {
00150     delete m_recEvt;
00151     m_recEvt = NULL;
00152   }
00153   if (m_dstEvt != NULL) {
00154     delete m_dstEvt;
00155     m_dstEvt = NULL;
00156   }
00157   if (m_mcEvt != NULL) {
00158     delete m_mcEvt;
00159     m_mcEvt = NULL;
00160   }
00161   if (m_rectrackEvt != NULL) {  //2007-10-04
00162     delete m_rectrackEvt;
00163     m_rectrackEvt = NULL;
00164   }
00165   if (m_EvtHeader != NULL){
00166     delete m_EvtHeader;
00167     m_EvtHeader = NULL;
00168   }
00169   if(m_trigEvt != NULL){
00170     delete m_trigEvt;
00171     m_trigEvt = NULL;
00172   }
00173   if(m_hltEvt != NULL){
00174     delete m_hltEvt;
00175     m_hltEvt = NULL;
00176   } 
00177   if ( m_evtRecObject != NULL ) {
00178      delete m_evtRecObject;
00179      m_evtRecObject = NULL;
00180   }
00181   
00182   for (std::map<const MdcDigi*, TRef>::iterator iter = m_mdcDigiMap.begin();
00183       iter != m_mdcDigiMap.end(); iter++) {
00184     delete (*iter).second.GetObject();
00185     delete (*iter).first;
00186   }
00187   m_mdcDigiMap.clear();
00188   for (std::map<const TObject*, const MdcDigi*>::iterator iter = m_rootMdcDigiMap.begin();
00189       iter != m_rootMdcDigiMap.end(); iter++) {
00190     delete (*iter).first;
00191   }
00192   m_rootMdcDigiMap.clear();
00193   
00194   for (std::map<const EmcDigi*, TRef>::iterator iter = m_emcDigiMap.begin();
00195       iter != m_emcDigiMap.end(); iter++) {
00196     delete (*iter).second.GetObject();
00197     delete (*iter).first;
00198   }
00199   m_emcDigiMap.clear();
00200   for (std::map<const TObject*, const  EmcDigi*>::iterator iter = m_rootEmcDigiMap.begin();
00201       iter != m_rootEmcDigiMap.end(); iter++) {
00202     delete (*iter).first;
00203   }
00204   m_rootEmcDigiMap.clear();
00205   
00206   for (std::map<const TofDigi*, TRef>::iterator iter = m_tofDigiMap.begin();
00207       iter != m_tofDigiMap.end(); iter++) {
00208     delete (*iter).second.GetObject();
00209     delete (*iter).first;
00210   }
00211   m_tofDigiMap.clear();
00212   for (std::map<const TObject*, const  TofDigi*>::iterator iter = m_rootTofDigiMap.begin();
00213       iter != m_rootTofDigiMap.end(); iter++) {
00214     delete (*iter).first;
00215   }
00216   m_rootTofDigiMap.clear();
00217   
00218   for (std::map<const MucDigi*, TRef>::iterator iter = m_mucDigiMap.begin();
00219       iter != m_mucDigiMap.end(); iter++) {
00220     delete (*iter).second.GetObject();
00221     delete (*iter).first;
00222   }
00223   m_mucDigiMap.clear();
00224   for (std::map<const TObject*, const  MucDigi*>::iterator iter = m_rootMucDigiMap.begin();
00225       iter != m_rootMucDigiMap.end(); iter++) {
00226     delete (*iter).first;
00227   }
00228   m_rootMucDigiMap.clear();
00229 
00230   for ( std::map<const LumiDigi*, TRef>::iterator iter = m_lumiDigiMap.begin();
00231         iter != m_lumiDigiMap.end(); ++iter) {
00232      delete (*iter).second.GetObject();
00233      delete (*iter).first;
00234   }
00235   m_lumiDigiMap.clear();
00236   for ( std::map<const TObject*, const LumiDigi*>::iterator iter = m_rootLumiDigiMap.begin();
00237         iter != m_rootLumiDigiMap.end(); ++iter) {
00238      delete (*iter).first;
00239   }
00240   m_rootLumiDigiMap.clear();
00241   
00242   //for dst
00243   for (std::map<const DstEmcShower*, TRef>::iterator iter = m_emcShowerMap.begin();
00244       iter != m_emcShowerMap.end(); iter++) {
00245     delete (*iter).second.GetObject();
00246     delete (*iter).first;
00247   }
00248   m_emcShowerMap.clear();
00249   for (std::map<const TObject*, const  DstEmcShower*>::iterator iter = m_rootEmcShowerMap.begin();
00250       iter != m_rootEmcShowerMap.end(); iter++) {
00251     delete (*iter).first;
00252   }
00253   m_rootEmcShowerMap.clear();
00254   /*
00255   for (std::map<const DstMdcTrack*, TRef>::iterator p = m_mdcTrackMap.begin(); p != m_mdcTrackMap.end();p++){
00256     std::cout << "********The first is ****************" << (*p).first <<endl;
00257     //std::cout << "*********The second is " << (*p).second <<endl;
00258     }
00259   */
00260   for (std::map<const DstMdcTrack*, TRef>::iterator iter = m_mdcTrackMap.begin();
00261       iter != m_mdcTrackMap.end(); iter++) {
00262     delete (*iter).second.GetObject();
00263     delete (*iter).first;
00264   }
00265   m_mdcTrackMap.clear();
00266   for (std::map<const TObject*, const  DstMdcTrack*>::iterator iter = m_rootMdcTrackMap.begin();
00267       iter != m_rootMdcTrackMap.end(); iter++) {
00268     delete (*iter).first;
00269   }
00270   m_rootMdcTrackMap.clear();
00271   
00272   for (std::map<const DstMucTrack*, TRef>::iterator iter = m_mucTrackMap.begin();
00273       iter != m_mucTrackMap.end(); iter++) {
00274     delete (*iter).second.GetObject();
00275     delete (*iter).first;
00276   }
00277   m_mucTrackMap.clear();
00278   for (std::map<const TObject*, const  DstMucTrack*>::iterator iter = m_rootMucTrackMap.begin();
00279       iter != m_rootMucTrackMap.end(); iter++) {
00280     delete (*iter).first;
00281   }
00282   m_rootMucTrackMap.clear(); 
00283   
00284   for (std::map<const DstTofTrack*, TRef>::iterator iter = m_tofTrackMap.begin();
00285       iter != m_tofTrackMap.end(); iter++) {
00286     delete (*iter).second.GetObject();
00287     delete (*iter).first;
00288   }
00289   m_tofTrackMap.clear();
00290   for (std::map<const TObject*, const  DstTofTrack*>::iterator iter = m_rootTofTrackMap.begin();
00291       iter != m_rootTofTrackMap.end(); iter++) {
00292     delete (*iter).first;
00293   }
00294   m_rootTofTrackMap.clear(); 
00295   
00296   for (std::map<const DstMdcDedx*, TRef>::iterator iter = m_mdcDedxMap.begin();
00297       iter != m_mdcDedxMap.end(); iter++) {
00298     delete (*iter).second.GetObject();
00299     delete (*iter).first;
00300   }
00301   m_mdcDedxMap.clear();
00302   for (std::map<const TObject*, const  DstMdcDedx*>::iterator iter = m_rootMdcDedxMap.begin();
00303       iter != m_rootMdcDedxMap.end(); iter++) {
00304     delete (*iter).first;
00305   }
00306   m_rootMdcDedxMap.clear(); 
00307   
00308   for (std::map<const DstExtTrack*, TRef>::iterator iter = m_extTrackMap.begin();
00309       iter != m_extTrackMap.end(); iter++) {
00310     delete (*iter).second.GetObject();
00311     delete (*iter).first;
00312   }
00313   m_extTrackMap.clear();
00314   for (std::map<const TObject*, const  DstExtTrack*>::iterator iter = m_rootExtTrackMap.begin();
00315       iter != m_rootExtTrackMap.end(); iter++) {
00316     delete (*iter).first;
00317   }
00318   m_rootExtTrackMap.clear();
00319   
00320   for (std::map<const DstMdcKalTrack*, TRef>::iterator iter = m_mdcKalTrackMap.begin();
00321       iter != m_mdcKalTrackMap.end(); iter++) {
00322     delete (*iter).second.GetObject();
00323     delete (*iter).first;
00324   }
00325   m_mdcKalTrackMap.clear();
00326   for (std::map<const TObject*, const  DstMdcKalTrack*>::iterator iter = m_rootMdcKalTrackMap.begin();
00327       iter != m_rootMdcKalTrackMap.end(); iter++) {
00328     delete (*iter).first;
00329   }
00330   m_rootMdcKalTrackMap.clear();
00331   // for McTruth
00332   for (std::map<const MdcMcHit*, TRef>::iterator iter = m_mdcMcHitMap.begin();
00333       iter != m_mdcMcHitMap.end(); iter++) {
00334     delete (*iter).second.GetObject();
00335     delete (*iter).first;
00336   }
00337   m_mdcMcHitMap.clear();
00338   for (std::map<const TObject*, const MdcMcHit*>::iterator iter = m_rootMdcMcHitMap.begin();
00339       iter != m_rootMdcMcHitMap.end(); iter++) {
00340     delete (*iter).first;
00341   }
00342   m_rootMdcMcHitMap.clear();
00343   
00344   for (std::map<const EmcMcHit*, TRef>::iterator iter = m_emcMcHitMap.begin();
00345       iter != m_emcMcHitMap.end(); iter++) {
00346     delete (*iter).second.GetObject();
00347     delete (*iter).first;
00348   }
00349   m_emcMcHitMap.clear();
00350   for (std::map<const TObject*, const  EmcMcHit*>::iterator iter = m_rootEmcMcHitMap.begin();
00351       iter != m_rootEmcMcHitMap.end(); iter++) {
00352     delete (*iter).first;
00353   }
00354   m_rootEmcMcHitMap.clear();
00355   
00356   for (std::map<const TofMcHit*, TRef>::iterator iter = m_tofMcHitMap.begin();
00357       iter != m_tofMcHitMap.end(); iter++) {
00358     delete (*iter).second.GetObject();
00359     delete (*iter).first;
00360   }
00361   m_tofMcHitMap.clear();
00362   for (std::map<const TObject*, const  TofMcHit*>::iterator iter = m_rootTofMcHitMap.begin();
00363       iter != m_rootTofMcHitMap.end(); iter++) {
00364     delete (*iter).first;
00365   }
00366   m_rootTofMcHitMap.clear();
00367   
00368   for (std::map<const MucMcHit*, TRef>::iterator iter = m_mucMcHitMap.begin();
00369       iter != m_mucMcHitMap.end(); iter++) {
00370     delete (*iter).second.GetObject();
00371     delete (*iter).first;
00372   }
00373   m_mucMcHitMap.clear();
00374   for (std::map<const TObject*, const  MucMcHit*>::iterator iter = m_rootMucMcHitMap.begin();
00375       iter != m_rootMucMcHitMap.end(); iter++) {
00376     delete (*iter).first;
00377   }
00378   m_rootMucMcHitMap.clear();
00379   
00380   for (std::map<const McParticle*, TRef>::iterator iter = m_mcParticleMap.begin();
00381       iter != m_mcParticleMap.end(); iter++) {
00382     delete (*iter).second.GetObject();
00383     delete (*iter).first;
00384   }
00385   m_mcParticleMap.clear();
00386   for (std::map<const TObject*, const  McParticle*>::iterator iter = m_rootMcParticleMap.begin();
00387       iter != m_rootMcParticleMap.end(); iter++) {
00388     delete (*iter).first;
00389   }
00390   m_rootMcParticleMap.clear();
00391 
00392   //m_decayModeMap.clear();
00393   //m_rootDecayModeMap.clear();
00394 
00395 //m_decayModeMap.clear();
00396 //m_rootDecayModeMap.clear();
00397 
00398   //for Trig
00399   m_trigDataMap.clear();
00400   m_rootTrigDataMap.clear();
00401 
00402   //for event filter
00403   for (std::map<const HltRaw*, TRef>::iterator iter = m_hltRawMap.begin();
00404        iter != m_hltRawMap.end(); iter++) {
00405     delete (*iter).second.GetObject();
00406     delete (*iter).first;
00407   }
00408   m_hltRawMap.clear();
00409   for (std::map<const TObject*, const  HltRaw*>::iterator iter = m_rootHltRawMap.begin();
00410        iter != m_rootHltRawMap.end(); iter++) {
00411     delete (*iter).first;
00412   }
00413   m_rootHltRawMap.clear();
00414   m_hltInfMap.clear();
00415   m_rootHltInfMap.clear();
00416   m_dstHltInfMap.clear();
00417   m_rootDstHltInfMap.clear();
00418   //for Rec
00419   //Mdc
00420   for (std::map<const RecMdcTrack*, TRef>::iterator iter = m_recMdcTrackMap.begin();
00421       iter != m_recMdcTrackMap.end(); iter++) {
00422     delete (*iter).second.GetObject();
00423     delete (*iter).first;
00424   }
00425   m_recMdcTrackMap.clear();
00426   for (std::map<const TObject*, const  RecMdcTrack*>::iterator iter = m_rootRecMdcTrackMap.begin();
00427       iter != m_rootRecMdcTrackMap.end(); iter++) {
00428     delete (*iter).first;
00429   }
00430   m_rootRecMdcTrackMap.clear(); 
00431   for (std::map<const RecMdcHit*, TRef>::iterator iter = m_recMdcHitMap.begin();
00432       iter != m_recMdcHitMap.end(); iter++) {
00433     delete (*iter).second.GetObject();
00434     delete (*iter).first;
00435   }
00436   m_recMdcHitMap.clear();
00437   for (std::map<const TObject*, const  RecMdcHit*>::iterator iter = m_rootRecMdcHitMap.begin();
00438       iter != m_rootRecMdcHitMap.end(); iter++) {
00439     delete (*iter).first;
00440   }
00441   m_rootRecMdcHitMap.clear(); 
00442 
00443 //for Rec
00444   for (std::map<const RecEmcHit*, TRef>::iterator iter = m_recEmcHitMap.begin();
00445       iter != m_recEmcHitMap.end(); iter++) {
00446     delete (*iter).second.GetObject();
00447     delete (*iter).first;
00448   }
00449   m_recEmcHitMap.clear();
00450   for (std::map<const TObject*, const  RecEmcHit*>::iterator iter = m_rootRecEmcHitMap.begin();
00451       iter != m_rootRecEmcHitMap.end(); iter++) {
00452     delete (*iter).first;
00453   }
00454   m_rootRecEmcHitMap.clear();
00455 
00456   for (std::map<const RecEmcCluster*, TRef>::iterator iter = m_recEmcClusterMap.begin();
00457       iter != m_recEmcClusterMap.end(); iter++) {
00458     delete (*iter).second.GetObject();
00459     delete (*iter).first;
00460   }
00461   m_recEmcClusterMap.clear();
00462   for (std::map<const TObject*, const  RecEmcCluster*>::iterator iter = m_rootRecEmcClusterMap.begin();
00463       iter != m_rootRecEmcClusterMap.end(); iter++) {
00464     delete (*iter).first;
00465   }
00466   m_rootRecEmcClusterMap.clear();
00467 
00468   for (std::map<const RecEmcShower*, TRef>::iterator iter = m_recEmcShowerMap.begin();
00469       iter != m_recEmcShowerMap.end(); iter++) {
00470     delete (*iter).second.GetObject();
00471     delete (*iter).first;
00472   }
00473   m_recEmcShowerMap.clear();
00474   for (std::map<const TObject*, const  RecEmcShower*>::iterator iter = m_rootRecEmcShowerMap.begin();
00475       iter != m_rootRecEmcShowerMap.end(); iter++) {
00476     delete (*iter).first;
00477   }
00478   m_rootRecEmcShowerMap.clear();
00479 
00480   for (std::map<const RecTofTrack*, TRef>::iterator iter = m_RecTofTrackMap.begin();
00481        iter != m_RecTofTrackMap.end(); iter++) {
00482     delete (*iter).second.GetObject();
00483     delete (*iter).first;
00484   }
00485   m_RecTofTrackMap.clear();
00486   for (std::map<const TObject*, const  RecTofTrack*>::iterator iter = m_rootRecTofTrackMap.begin();
00487       iter != m_rootRecTofTrackMap.end(); iter++) {
00488     delete (*iter).first;
00489   }
00490   m_rootRecTofTrackMap.clear(); 
00491 
00492   for (std::map<const RecMucTrack*, TRef>::iterator iter = m_RecMucTrackMap.begin();
00493       iter != m_RecMucTrackMap.end(); iter++) {
00494     delete (*iter).second.GetObject();
00495     delete (*iter).first;
00496   }
00497   m_RecMucTrackMap.clear();
00498   for (std::map<const TObject*, const  RecMucTrack*>::iterator iter = m_rootRecMucTrackMap.begin();
00499       iter != m_rootRecMucTrackMap.end(); iter++) {
00500     delete (*iter).first;
00501   }
00502   m_rootRecMucTrackMap.clear(); 
00503   
00504   for (std::map<const RecMdcDedx*, TRef>::iterator iter = m_recMdcDedxMap.begin();
00505       iter != m_recMdcDedxMap.end(); iter++) {
00506     delete (*iter).second.GetObject();
00507     delete (*iter).first;
00508   }
00509   m_recMdcDedxMap.clear();
00510   for (std::map<const TObject*, const  RecMdcDedx*>::iterator iter =  m_rootRecMdcDedxMap.begin();
00511       iter !=  m_rootRecMdcDedxMap.end(); iter++) {
00512     delete (*iter).first;
00513   }
00514    m_rootRecMdcDedxMap.clear();
00515 
00516 
00517   for (std::map<const RecMdcDedxHit*, TRef>::iterator iter = m_recMdcDedxHitMap.begin();
00518       iter != m_recMdcDedxHitMap.end(); iter++) {
00519     delete (*iter).second.GetObject();
00520     delete (*iter).first;
00521   }
00522   m_recMdcDedxHitMap.clear();
00523   for (std::map<const TObject*, const  RecMdcDedxHit*>::iterator iter =  m_rootRecMdcDedxHitMap.begin();
00524       iter !=  m_rootRecMdcDedxHitMap.end(); iter++) {
00525     delete (*iter).first;
00526   }
00527   m_rootRecMdcDedxHitMap.clear();
00528 
00529   for (std::map<const RecMdcKalTrack*, TRef>::iterator iter = m_recMdcKalTrackMap.begin();
00530       iter != m_recMdcKalTrackMap.end(); iter++) {
00531     delete (*iter).second.GetObject();
00532     delete (*iter).first;
00533   }
00534   m_recMdcKalTrackMap.clear();
00535   for (std::map<const TObject*, const  RecMdcKalTrack*>::iterator iter = m_rootRecMdcKalTrackMap.begin();
00536       iter != m_rootRecMdcKalTrackMap.end(); iter++) {
00537     delete (*iter).first;
00538   }
00539   m_rootRecMdcKalTrackMap.clear(); 
00540 
00541 
00542   for (std::map<const RecMdcKalHelixSeg*, TRef>::iterator iter = m_recMdcKalHelixSegMap.begin();
00543       iter != m_recMdcKalHelixSegMap.end(); iter++) {
00544     delete (*iter).second.GetObject();
00545     delete (*iter).first;
00546   }
00547   m_recMdcKalHelixSegMap.clear();
00548   for (std::map<const TObject*, const  RecMdcKalHelixSeg*>::iterator iter = m_rootRecMdcKalHelixSegMap.begin();
00549       iter != m_rootRecMdcKalHelixSegMap.end(); iter++) {
00550     delete (*iter).first;
00551   }
00552   m_rootRecMdcKalHelixSegMap.clear(); 
00553 
00554 //Estime
00555     
00556   for (std::map<const RecEsTime*, TRef>::iterator iter = m_RecEvTimeMap.begin();
00557       iter != m_RecEvTimeMap.end(); iter++) {
00558     delete (*iter).second.GetObject(); 
00559     delete (*iter).first;
00560   } 
00561   m_RecEvTimeMap.clear();
00562   for (std::map<const TObject*, const  RecEsTime*>::iterator iter = m_rootRecEvTimeMap.begin();
00563       iter != m_rootRecEvTimeMap.end(); iter++) {
00564     delete (*iter).first;
00565   }
00566   m_rootRecEvTimeMap.clear();
00567 
00568   // for event after EventAssembly
00569   for (std::map<const EvtRecTrack*, TRef>::iterator iter = m_EvtRecTrackMap.begin();
00570         iter != m_EvtRecTrackMap.end(); iter++ ) {
00571      delete (*iter).second.GetObject();
00572      delete (*iter).first;
00573   }
00574   m_EvtRecTrackMap.clear();
00575   for (std::map<const TObject*, const EvtRecTrack*>::iterator iter = m_rootEvtRecTrackMap.begin();
00576         iter != m_rootEvtRecTrackMap.end(); iter++) {
00577      delete iter->first;
00578   }
00579   m_rootEvtRecTrackMap.clear();
00580 
00581   // EvtRecVeeVertexCol
00582   for (std::map<const EvtRecVeeVertex*, TRef>::iterator iter = m_evtRecVeeVertexMap.begin();
00583       iter != m_evtRecVeeVertexMap.end(); iter++) {
00584     delete (*iter).second.GetObject();
00585     delete (*iter).first;
00586   }
00587   m_evtRecVeeVertexMap.clear();
00588   for (std::map<const TObject*, const  EvtRecVeeVertex*>::iterator iter = m_rootEvtRecVeeVertexMap.begin();
00589       iter != m_rootEvtRecVeeVertexMap.end(); iter++) {
00590     delete (*iter).first;
00591   }
00592   m_rootEvtRecVeeVertexMap.clear();
00593 
00594   //EvtRecPi0Col
00595   for (std::map<const EvtRecPi0*, TRef>::iterator iter = m_evtRecPi0Map.begin();
00596       iter != m_evtRecPi0Map.end(); iter++) {
00597     delete (*iter).second.GetObject();
00598     delete (*iter).first;
00599   }
00600   m_evtRecPi0Map.clear();
00601   for (std::map<const TObject*, const  EvtRecPi0*>::iterator iter = m_rootEvtRecPi0Map.begin();
00602       iter != m_rootEvtRecPi0Map.end(); iter++) {
00603     delete (*iter).first;
00604   }
00605   m_rootEvtRecPi0Map.clear();
00606 
00607 
00608   //EvtRecEtaToGGCol
00609   for (std::map<const EvtRecEtaToGG*, TRef>::iterator iter = m_evtRecEtaToGGMap.begin();
00610       iter != m_evtRecEtaToGGMap.end(); iter++) {
00611     delete (*iter).second.GetObject();
00612     delete (*iter).first;
00613   }
00614   m_evtRecEtaToGGMap.clear();
00615   for (std::map<const TObject*, const  EvtRecEtaToGG*>::iterator iter = m_rootEvtRecEtaToGGMap.begin();
00616       iter != m_rootEvtRecEtaToGGMap.end(); iter++) {
00617     delete (*iter).first;
00618   }
00619   m_rootEvtRecEtaToGGMap.clear();
00620 
00621   
00622 
00623   // EvtRecDTagCol
00624   for (std::map<const EvtRecDTag*, TRef>::iterator iter = m_evtRecDTagMap.begin();
00625       iter != m_evtRecDTagMap.end(); iter++) {
00626     delete (*iter).second.GetObject();
00627     delete (*iter).first;
00628   }
00629   m_evtRecDTagMap.clear();
00630   for (std::map<const TObject*, const  EvtRecDTag*>::iterator iter = m_rootEvtRecDTagMap.begin();
00631       iter != m_rootEvtRecDTagMap.end(); iter++) {
00632     delete (*iter).first;
00633   }
00634   m_rootEvtRecDTagMap.clear();
00635 
00636 }

Member Data Documentation

TDstEvent* commonData::m_dstEvt [static]
 

Provide access to the ROOT event pointers.

TDstEvent * commonData::m_dstEvt = NULL [static]
 

Provide access to the ROOT event pointers.

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

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

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

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

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

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

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

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

TEvtHeader* commonData::m_EvtHeader [static]
 

TEvtHeader * commonData::m_EvtHeader = NULL [static]
 

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

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

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

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

TEvtRecObject* commonData::m_evtRecObject [static]
 

TEvtRecObject * commonData::m_evtRecObject = NULL [static]
 

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

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

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

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

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

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

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

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

THltEvent* commonData::m_hltEvt [static]
 

Provide access to the ROOT event pointers.

THltEvent * commonData::m_hltEvt = NULL [static]
 

Provide access to the ROOT event pointers.

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

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

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

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

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

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

TMcEvent* commonData::m_mcEvt [static]
 

Provide access to the ROOT event pointers.

TMcEvent * commonData::m_mcEvt = NULL [static]
 

Provide access to the ROOT event pointers.

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

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

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

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

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.

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

TDigiEvent* commonData::m_recEvt [static]
 

Provide access to the ROOT event pointers.

TDigiEvent * commonData::m_recEvt = NULL [static]
 

Provide access to the ROOT event pointers.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

TRecTrackEvent* commonData::m_rectrackEvt [static]
 

Provide access to the ROOT event pointers.

TRecTrackEvent * commonData::m_rectrackEvt = NULL [static]
 

Provide access to the ROOT event pointers.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

TTrigEvent* commonData::m_trigEvt [static]
 

Provide access to the ROOT event pointers.

TTrigEvent * commonData::m_trigEvt = NULL [static]
 

Provide access to the ROOT event pointers.

The documentation for this class was generated from the following files:
Generated on Wed Feb 2 15:56:27 2011 for BOSS6.5.5 by  doxygen 1.3.9.1