TesIO.h

Go to the documentation of this file.

//
#ifndef ATLFAST_TESIO_H
#define ATLFAST_TESIO_H

// STL
#include <vector>
#include <string>


//Generator includes
//#include "GeneratorObjects/McEventCollection.h"

#ifndef GAUDIKERNEL_BOOTSTRAP_H
#include "GaudiKernel/Bootstrap.h"
#define GAUDIKERNEL__BOOTSTRAP_H
#endif

#ifndef GAUDIKERNEL_ISVCLOCATOR_H
#include "GaudiKernel/ISvcLocator.h"
#define GAUDIKERNEL__ISVCLOCATOR_H
#endif


/*
#ifndef GAUDIKERNEL_DATAOBJECT_H
#include "GaudiKernel/DataObject.h"
#define GAUDIKERNEL_DATAOBJECT_H
#endif


#ifndef GAUDIKERNEL_OBJECTVECTOR_H
#include "GaudiKernel/ObjectVector.h"
#define GAUDIKERNEL_OBJECTVECTOR_H
#endif
*/
// StoreGate

#ifndef STOREGATE_STOREGATESVC_H
#include "StoreGate/StoreGateSvc.h"
#define STOREGATE_STOREGATESVC_H
#endif

#ifndef STOREGATE_DATAHANDLE_H
#include "StoreGate/DataHandle.h"
#define STOREGATE_DATAHANDLE_H
#endif

#ifndef ATLFASTEVENT_MCPARTICLECOLLECTION_H
#include "AtlfastEvent/MCparticleCollection.h" // no forward decl - typedefs!
#endif

#ifndef ATLFASTEVENT_MCPARTICLECOLLECTION_H
#include "AtlfastEvent/MCparticleCollection.h" // no forward decl - typedefs!
#endif

#ifndef ATLFAST_MCWEIGHTCONTAINERCOLLECTION_H
#include "AtlfastEvent/MCweightContainerCollection.h" //no forw decl: typedefs!
#endif

namespace HepMC_helper{
  class IMCselector;
}


namespace Atlfast {
  class TesIoStat{
  public:
    TesIoStat(): m_status(StatusCode::SUCCESS),m_errMsg(""){}
    TesIoStat(StatusCode sc, std::string string): m_status(sc),
      m_errMsg(string){}
    TesIoStat(StatusCode s): m_status(s), m_errMsg(""){}
    
    StatusCode status()   const {return m_status;}
    std::string message() const {return m_errMsg;}

    bool isValid()        const {return m_status.isSuccess();}
    bool isNotValid()     const {return !isValid();}
    bool operator !()     const {return isNotValid();}
    operator bool()       const {return isValid();}
    operator StatusCode() const {return m_status;}
  private:
    StatusCode m_status;
    std::string m_errMsg;
  };
  
  class TesIO {
  public:
    typedef std::string String;
    //
    TesIO(std::string mcLocation="", bool justHardScatter=true);
    TesIoStat getMC          (MCparticleCollection&)                     const;
    TesIoStat getMC          (MCparticleCollection&, 
                             const HepMC_helper::IMCselector* )          const;
    TesIoStat getMCweightContainers   
                             (MCweightContainerCollection&)              const;
    //
    template<class T> TesIoStat getDH (const T*&)                        const;
    template<class T> TesIoStat getDH (const T*&, String key)            const;
    template<class T> TesIoStat store (T*)                               const;
    template<class T> TesIoStat store (T*,   String key)                 const;
    template<class T> TesIoStat store (T*,   String key, bool allowmods) const;
    template<class T> TesIoStat lock  (T*)                               const;
    
    template<class T, 
             class U> TesIoStat copy  (U&,                   String key) const;
  private:
    // StoreGate key for the MCEventCollection
    std::string   m_mcLocation;
    bool          m_justHardScatter;
    StoreGateSvc* m_sgSvc;
  };


  //**************************************************************************
  // TesIO()                                                                 *
  //**************************************************************************
  inline TesIO::TesIO(std::string mcLocation, bool justHardScatter):
    m_mcLocation(mcLocation), m_justHardScatter(justHardScatter), m_sgSvc(0) {
    ISvcLocator* svcLoc = Gaudi::svcLocator( );
    if( (svcLoc->service( "StoreGateSvc", m_sgSvc )).isFailure() ){
      throw TesIoStat(StatusCode::FAILURE, "TesIO could not find StoreGate");
    }
  }
  //**************************************************************************
  //TesIoStat template class<T, u> TesIO::copy(U, String key) const*
  //**************************************************************************
  template<class T, class U> inline 
    TesIoStat TesIO::copy(U& localCopy, String key) const {
    const T* objects(0);
    TesIoStat stat = this->getDH(objects, key);
    if(!stat){
      return TesIoStat(StatusCode::FAILURE,
                       "Could not copyCollection keyed collection: "+stat.message());
    }

    std::copy(objects->begin(),objects->end(),std::back_inserter(localCopy));
    return TesIoStat(StatusCode::SUCCESS, "Copied Collection from TDS");
    
  }
  //**************************************************************************
  //*TesIoStat TesIO::getDH(const DataHandle<T>& dh) const                   *
  //**************************************************************************
  template<class T> inline 
    TesIoStat TesIO::getDH(const T*& dh) const {
    // std::cout<<"CCT+PS TesIO:: getDH(DH)"<<m_mcLocation<<std::endl;
    if((m_sgSvc->retrieve(dh)).isFailure() ){
      return TesIoStat(StatusCode::FAILURE,
                       "Could not find a valid DataHandle");
    }
    return TesIoStat(StatusCode::SUCCESS, "Found unkeyed DH in TDS");
  }
  //**************************************************************************
  //*TesIoStat TesIO::getDH(const DataHandle<T>& dh, String key) const       *
  //**************************************************************************
  template<class T> inline 
    TesIoStat TesIO::getDH(const T*& dh, String key) const {
    // std::cout<<"CCT+PS TesIO:: getDH(DH+STRING)"<<m_mcLocation<<std::endl;
    if( (m_sgSvc->retrieve(dh, key)).isFailure() ){
      return TesIoStat(StatusCode::FAILURE,
                       "Could not find a valid keyed DataHandle");
    }
    return TesIoStat(StatusCode::SUCCESS, "Found keyed DH in TDS");
  }
  //**************************************************************************
  //template<class T> inline TesIoStat TesIO::store(T* pObject) const        *
  //**************************************************************************
  template<class T> inline TesIoStat TesIO::store(T* pObject) const { 
    return (TesIoStat(m_sgSvc->record(pObject,false)) ) ;
  }
  //*******************************************************************************
  //template<class T> inline TesIoStat TesIO::store(T* pObject, String key) const *
  //*******************************************************************************
  template<class T> inline 
    TesIoStat TesIO::store(T* pObject, String key) const { 
    return (TesIoStat(m_sgSvc->record(pObject, key, false)) ) ;
  }
  //**************************************************************************
  //template<class T> inline TesIoStat TesIO::store(T* pObject,              *
  //                  String key, bool allowmods) const                      *
  //**************************************************************************
  template<class T> inline 
    TesIoStat TesIO::store(T* pObject, String key, bool allowmods) const { 
    return (TesIoStat(m_sgSvc->record(pObject, key, allowmods)) ) ;
  }
  //**************************************************************************
  //template<class T> inline TesIoStat TesIO::lock(T* pObject) const         *
  //**************************************************************************
  template<class T> inline TesIoStat TesIO::lock(T* pObject) const { 
    return (TesIoStat(m_sgSvc->setConst(pObject)) ) ;
  }
  
}
#endif

---