#ifndef METREFINEMENT_METREFINEDTOOLBASE_H
 #define METREFINEMENT_METREFINEDTOOLBASE_H
 /*****************************************************************************
 
 NAME:     METRefinedToolBase
 PACKAGE:  offline/Reconstruction/MissingET
 
 AUTHORS:  P. Loch
 CREATED:  Apr, 2006
 
 PURPOSE:  Templated base class for Refined MissingEt calculation tools.
           Each RefTool needs the association map as argument in the execute
 
 *****************************************************************************/
 #include "GaudiKernel/MsgStream.h"
 #include "GaudiKernel/AlgTool.h"
 #include "GaudiKernel/Service.h"
 
 #include "StoreGate/StoreGateSvc.h"
 
 #include "MissingETEvent/MissingEtMap.h"
 #include "MissingETEvent/MissingET.h"
 
 #include <string>
 #include <vector>
 
 #include <typeinfo>
 
 template<typename KEYOBJECT,typename LISTOBJECT>
 
 /**                                                                                     
   * METRefinedToolBase class.
   * 
   * Templated base class for Refined MissingEt calculation tools.
   * Each RefTool needs the association map as argument in the execute
   * 
   * 
   * @author loch@physics.arizona.edu
   */
 
 class METRefinedToolBase : public AlgTool
 {
 public:
 
   // example: KEYOBJECT  = CaloCell
   //          LISTOBJECT = CaloCluster
   typedef MissingEtMap<KEYOBJECT>         map_t;
   typedef std::vector<const LISTOBJECT*>  list_t;
 
   METRefinedToolBase(const std::string& type, const std::string& name,
                     const IInterface* pParent);
   virtual ~METRefinedToolBase();
 
   virtual StatusCode initialize() ;
 
   virtual StatusCode execute(map_t* mapStore,list_t* listStore=0) = 0;
 
 protected:
 
   // property: StoreGate key for missing Et object
   std::string m_missingETKey;
 
   // property: flag requests tracking of used obejcts (true) or not.
   bool m_trackUsedObjects;
 
   // StoreGate service pointer
   StoreGateSvc* m_storeGate;
 
   // helper: make entry selection based on object type only
   template<typename RELOBJECT>
   bool entrySelection(const KEYOBJECT* pKey, map_t* mapStore) const
   {
     return this->entrySelection<RELOBJECT>(mapStore->find(pKey),mapStore);
   }
 
   template<typename RELOBJECT>
   bool entrySelection(const size_t& iKey, map_t* mapStore) const
   {
     return this->entrySelection<RELOBJECT>(mapStore->find(iKey),mapStore);
   }
 
   template<typename RELOBJECT>
   bool entrySelection(typename map_t::const_iterator fKey,
                       map_t* mapStore) const
   {
     //MsgStream report(msgSvc(),name());
     
     if ( fKey != mapStore->end() ) //if the key is already inside the map
       {
         // faster check on associations
         if ( (fKey.getRefStore()).empty() )
           {
             //      report << MSG::INFO
             //             << "object (index/pointer): ("
             //             << fKey - (mapStore->begin())
             //             << "/"
             //             << fKey.getKeyObject()
             //             << "): no associations yet!"
             //     << endreq;
             return true; // cell can be added to map
           }
         // some associations already existing
         else
           {
             // debug
             //      report << MSG::INFO
             //             << "object (index/pointer): "
             //             << "(" << fKey-(mapStore->begin())
             //             << "/" << fKey.getKeyObject()
             //             << ") has "
             //             << (fKey.getRefStore()).size()
             //             << " associations already"
             //             << endreq;
             // check if ALL referenced objects are of allowed type!
             //      typename map_t::ref_iterator fRef = mapStore->begin(fKey);
             //      typename map_t::ref_iterator lRef = mapStore->end(fKey);
             typename map_t::const_ref_iterator fRef = (fKey.getRefStore()).begin();
             typename map_t::const_ref_iterator lRef = (fKey.getRefStore()).end();
             unsigned int refCtr(0); 
             unsigned int refAssCtr(0);
             // debugging only: create a dummy object for type info 
             ///*debug*/     const RELOBJECT* tstObj = new RELOBJECT();
             ///*debug*/     std::string tryType = typeid(tstObj).name();
             ///*debug*/     delete tstObj;
             for ( ; fRef != lRef; fRef++ )  //loop on all associated ref obj
               {
                 ++refCtr;        //count the ref obj
                 //              std::string assType = typeid(fRef.getObjectPtr()).name();
                 if ( dynamic_cast<const RELOBJECT*>(fRef.getObjectPtr()) 
                      != 0 ) 
                   {
                     //              assType = tryType;
                     ++refAssCtr ;
                   }
                 //              report << MSG::INFO
                 //                     << "object (index/pointer): ("
                 //                     << fKey-(mapStore->begin())
                 //                     << "/"
                 //                     << fKey.getKeyObject()
                 //                     << ") requested association type <"
                 //                     << tryType
                 //                     << ">, found association type <"
                 //                     << assType
                 //                     << ">, counters: "
                 //                     << refAssCtr << "/"
                 //                     << refCtr
                 //                     << endreq;
               }
             return refCtr == refAssCtr;
           }  
       }
     else
       {
         return true;
       }
   }
 
   // helper: private tool initialization
   virtual StatusCode initTool() { return StatusCode::SUCCESS; }
 
   // helper: get new missing Et object
   virtual MissingET* getMissingETObject();
 
   // helper: record missing Et object
   virtual StatusCode recordMissingETObject(MissingET* pObj);
 
   // helper: add list object to list of used objects
   virtual StatusCode addUsedObject(const LISTOBJECT* pRef,
                                    list_t* pList);   
 };
 
 /////////////////////////////////
 // Constructors and Destructor //
 /////////////////////////////////
 
 template<typename KEYOBJECT,typename LISTOBJECT>
 METRefinedToolBase<KEYOBJECT,LISTOBJECT>::METRefinedToolBase(const std::string&
                                                              type,
                                                              const 
                                                              std::string& 
                                                              name,
                                                              const IInterface*
                                                              pParent) 
   : AlgTool(type,name,pParent),
     m_trackUsedObjects(true)
 {
   declareProperty("MissingETKey",m_missingETKey);
   declareProperty("TrackUsedObjects",m_trackUsedObjects);
 }
 
 template<typename KEYOBJECT,typename LISTOBJECT>
 METRefinedToolBase<KEYOBJECT,LISTOBJECT>::~METRefinedToolBase() 
 { }
 
 ////////////////////////////////
 // Common Tool Initialization //
 ////////////////////////////////
 
 template<typename KEYOBJECT,typename LISTOBJECT>
 StatusCode
 METRefinedToolBase<KEYOBJECT,LISTOBJECT>::initialize()
 {
   // allocate StoreGate service
   if ( (service("StoreGateSvc",m_storeGate)).isFailure() )
     {
       MsgStream report(msgSvc(),name());
       report << MSG::ERROR 
              << "cannot allocate StoreGate service"
              << endreq;
       return StatusCode::FAILURE;
     }
   else
     {
       return this->initTool();
     }
 }
 
 /////////////
 // Helpers //
 /////////////
 
 // The entrySelection(...) method is the most general implementation of an
 // acceptor for a new entry into the map relating key objects with
 // referenced objects. The idea that if ALL referenced objects are of the
 // same type for which the client wants to add a new relation to a key
 // object, the acceptor returns "true". If there is a relation to ANY other
 // reference object type in the map, the acceptor returns "false". The
 // consequential action should be implemented in the concrete tool itself.
 
 // entry selection by object pointer
 //template<typename KEYOBJECT,typename LISTOBJECT,typename RELOBJECT>
 //bool
 //METRefinedToolBase<KEYOBJECT,LISTOBJECT>::
 //entrySelection(const KEYOBJECT* pKey,map_t* mapStore)
 //{
 //  return this->entrySelection<RELOBJECT>(mapStore->find(pKey),mapStore);
 //}
 
 // entry selection by index
 //template<typename KEYOBJECT,typename LISTOBJECT,typename RELOBJECT>
 //bool
 //METRefinedToolBase<KEYOBJECT,LISTOBJECT>::entrySelection(const 
 //                                                                  size_t& 
 //                                                                  iKey,
 //                                                                  map_t*
 //                                                                  mapStore)
 
 // entry selection by iterator
 //template<typename KEYOBJECT,typename LISTOBJECT,typename RELOBJECT>
 //bool
 //METRefinedToolBase<KEYOBJECT,LISTOBJECT>::
 //entrySelection(map_t::const_iterator fKey, map_t* mapStore)
 
 // create and record a new missing Et object
 template<typename KEYOBJECT,typename LISTOBJECT>
 MissingET*
 METRefinedToolBase<KEYOBJECT,LISTOBJECT>::getMissingETObject()
 {
   // new object
   MissingET* pEtMiss = new MissingET();
   // record in StoreGate
   if ( m_storeGate == 0 || 
        ( m_storeGate->record(pEtMiss,m_missingETKey) ).isFailure() )
     {
       delete pEtMiss; 
       return (MissingET*)0;
     }
   return pEtMiss;
 }
 
 // lock missing Et object in StoreGate
 template<typename KEYOBJECT,typename LISTOBJECT>
 StatusCode
 METRefinedToolBase<KEYOBJECT,LISTOBJECT>::recordMissingETObject(MissingET* 
                                                                 pEtObj)
 {
   return m_storeGate != 0 && pEtObj != 0 
     ? m_storeGate->setConst(pEtObj) : StatusCode::FAILURE;
 }
 
 // add used LISTOBJECT to list
 template<typename KEYOBJECT,typename LISTOBJECT>
 StatusCode
 METRefinedToolBase<KEYOBJECT,LISTOBJECT>::addUsedObject(const LISTOBJECT* pObj,
                                                         list_t* pList)
 {
   size_t oldSize(pList->size());
   pList->push_back(pObj);
   return pList->size() > oldSize ? StatusCode::SUCCESS : StatusCode::FAILURE;
 }
 
 
 #endif

Due to the LXR bug, the updates fail sometimes to remove references to deleted files. The Saturday's full rebuilds fix these problems
This page was automatically generated by the LXR engine.