Skip to content
Snippets Groups Projects
Commit 210b1776 authored by Andrzej Zemla's avatar Andrzej Zemla Committed by Graeme Stewart
Browse files

adding MBTSModule and ForwardEventInfo converters (xAODForwardCnv-00-00-01)

parent 6e7651f2
No related branches found
No related tags found
No related merge requests found
Showing
with 823 additions and 0 deletions
package xAODForwardCnv
author azemla@cern.ch
# Base package(s):
public
use AtlasPolicy AtlasPolicy-*
use GaudiInterface GaudiInterface-* External
use xAODForward xAODForward-* Event/xAOD
#old EDM packages
use TileEvent TileEvent-* TileCalorimeter
use TileIdentifier TileIdentifier-* TileCalorimeter
private
use AthenaBaseComps AthenaBaseComps-* Control
use AthenaKernel AthenaKernel-* Control
end_private
# Make a component library:
library xAODForwardCnv *.cxx components/*.cxx
apply_pattern component_library
# Install the additinal files
apply_pattern declare_joboptions files="*.py"
apply_pattern declare_python_modules files="*.py"
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id: xAODForwardEventInfoCreator.py 578517 2014-01-15 13:48:04Z krasznaa $
# Import the package's configurables:
from xAODForwardCnv.xAODForwardCnvConf import *
## Helper function for creating xAOD ForwardEventInfo objects
def xAODForwardEventInfoCreator( sequence = None, stream = None,
key = "MBTSCollisionTime" ):
"""
Helper function that schedules all the components that create xAOD
ForwardEventInfo objects out of existing AOD objects.
Arguments:
sequence: Optional sequence to which the components should be added.
If not specified, the main algorithm sequence is used.
stream: Optional stream that the objects should be written to.
If not specified, the objects are added to StreamAOD.
key: Optional StoreGate key for the AOD object that is supposed to be
translated.
"""
# Create a logger for the function:
if "logger" in dir(): orig_logger = logger
from AthenaCommon.Logging import logging
logger = logging.getLogger( "xAODForwardEventInfoCreator" )
# Tell the user what's happening:
logger.info( "Creating xAOD::ForwardEventInfo from MBTSCollisionTime" )
# Get the main sequence if necessary:
if sequence == None:
from AthenaCommon.AlgSequence import AlgSequence
sequence = AlgSequence()
pass
# Access the stream if necessary:
if stream == None:
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
stream = MSMgr.GetStream( "StreamAOD" )
pass
# Schedule the converter algorithm:
alg = xAODMaker__ForwardEventInfoCnvAlg()
alg.AODKey = key
alg.xAODKey = key
sequence += alg
# Add the created objects to the output:
stream.AddItem( "xAOD::MBTSForwardEventInfo_v1#%s" % key )
stream.AddItem( "xAOD::MBTSForwardEventInfoAuxInfo_v1#%sAux." % key )
# Reinstate the old logger if it existed:
if "orig_logger" in dir(): logger = orig_logger
pass
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id: xAODMBTSModuleCreator.py 578517 2014-01-15 13:48:04Z krasznaa $
# Import the package's configurables:
from xAODForwardCnv.xAODForwardCnvConf import *
## Helper function for creating xAOD MBTSModule objects
def xAODMBTSModuleCreator( sequence = None, stream = None,
key = "MBTSContainer" ):
"""
Helper function that schedules all the components that create xAOD
MBTSModule objects out of existing AOD objects.
Arguments:
sequence: Optional sequence to which the components should be added.
If not specified, the main algorithm sequence is used.
stream: Optional stream that the objects should be written to.
If not specified, the objects are added to StreamAOD.
key: Optional StoreGate key for the AOD object that is supposed to be
translated.
"""
# Create a logger for the function:
if "logger" in dir(): orig_logger = logger
from AthenaCommon.Logging import logging
logger = logging.getLogger( "xAODMBTSModuleCreator" )
# Tell the user what's happening:
logger.info( "Creating xAOD::MBTSModule from TrigDec::MBTSModule" )
# Get the main sequence if necessary:
if sequence == None:
from AthenaCommon.AlgSequence import AlgSequence
sequence = AlgSequence()
pass
# Access the stream if necessary:
if stream == None:
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
stream = MSMgr.GetStream( "StreamAOD" )
pass
# Schedule the converter algorithm:
alg = xAODMaker__MBTSModuleCnvAlg()
alg.AODKey = key
alg.xAODKey = key
sequence += alg
# Add the created objects to the output:
stream.AddItem( "xAOD::MBTSModule_v1#%s" % key )
stream.AddItem( "xAOD::MBTSModuleAuxInfo_v1#%sAux." % key )
# Reinstate the old logger if it existed:
if "orig_logger" in dir(): logger = orig_logger
pass
# Enable xAOD making:
from RecExConfig.RecFlags import rec
rec.doWritexAOD = True
#FNAME="/afs/cern.ch/work/a/azemla/xAODDevelop/rel_2_test/test/MinBiasSliceAthenaTrigRDO/AOD.pool.root"
FNAME="AOD.pool.root"
include( "AthenaPython/iread_file.py" )
# Access the algorithm sequence:
from AthenaCommon.AlgSequence import AlgSequence
theJob = AlgSequence()
# Create a logger object:
from AthenaCommon.Logging import logging
logger = logging.getLogger( "xAODForwardCnv_jobOptions" )
# Create a POOL output file with the StoreGate contents:
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
xaodStream = MSMgr.NewPoolStream( "StreamAOD", "xAOD.pool.root" )
# Create some xAOD::TrigMinBias objects:
from xAODForwardCnv.xAODMBTSModuleCreator import xAODMBTSModuleCreator
xAODMBTSModuleCreator()
from xAODForwardCnv.xAODForwardEventInfoCreator import xAODForwardEventInfoCreator
xAODForwardEventInfoCreator()
# Make sure that the event format object is added to the output:
theApp.CreateSvc += [ "xAODMaker::EventFormatSvc" ]
xaodStream.AddMetaDataItem( "xAOD::EventFormat_v1#EventFormat" )
# Check what happened to the stream:
xaodStream.Print()
# Split all branches:
ServiceMgr.AthenaPoolCnvSvc.PoolAttributes += [
"DEFAULT_SPLITLEVEL='1'" ]
# Force POOL to just simply use the StoreGate keys as branch names:
ServiceMgr.AthenaPoolCnvSvc.SubLevelBranchName = "<key>"
# Do some additional tweaking:
from AthenaCommon.AppMgr import theApp
theApp.EvtMax = 10
ServiceMgr.MessageSvc.OutputLevel = VERBOSE
ServiceMgr.MessageSvc.defaultLimit = 1000
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
// Gaudi/Athena include(s):
#include "AthenaKernel/errorcheck.h"
// Old mbts (tile) info!
#include "TileEvent/MBTSCollisionTime.h"
//New egamma
#include "xAODForward/ForwardEventInfoContainer.h"
#include "xAODForward/ForwardEventInfoAuxContainer.h"
// Local include(s):
#include "ForwardEventInfoCnvAlg.h"
namespace xAODMaker {
ForwardEventInfoCnvAlg::ForwardEventInfoCnvAlg( const std::string& name,
ISvcLocator* svcLoc )
: AthAlgorithm( name, svcLoc ),m_cnvTool( "xAODMaker::ForwardEventInfoCnvTool/ForwardEventInfoCnvTool", this ) {
declareProperty( "AODContainerName", m_aodContainerName = "MBTSCollisionTime" );
declareProperty( "xAODContainerName", m_xaodContainerName = "MBTSForwardEventInfo" );
declareProperty("CnvTool", m_cnvTool, "The converter tool for MBTSForwardEventInfo");
}
StatusCode ForwardEventInfoCnvAlg::initialize() {
ATH_MSG_INFO( "Initializing - Package version: " << PACKAGE_VERSION );
ATH_MSG_INFO( "AODContainerName = " << m_aodContainerName );
ATH_MSG_INFO( "xAODContainerName = " << m_xaodContainerName );
CHECK(m_cnvTool.retrieve());
// Return gracefully:
return StatusCode::SUCCESS;
}
StatusCode ForwardEventInfoCnvAlg::execute() {
// Retrieve the AOD particles:
const MBTSCollisionTime* aod = 0;
CHECK( evtStore()->retrieve(aod, m_aodContainerName) );
if (!aod) {
ATH_MSG_WARNING("No ForwardEventInfoCollection with key " << m_aodContainerName << " found. Do nothing.");
return StatusCode::SUCCESS;
}
ATH_MSG_INFO( "Retrieved particles with key: " << m_aodContainerName );
/////////////////////////////////////////////////////////////////////////////////////////
// Create the xAOD container and its auxiliary store:
xAOD::ForwardEventInfoContainer* xaod = new xAOD::ForwardEventInfoContainer();
CHECK( evtStore()->record( xaod, m_xaodContainerName ) );
xAOD::ForwardEventInfoAuxContainer* aux = new xAOD::ForwardEventInfoAuxContainer();
CHECK( evtStore()->record( aux, m_xaodContainerName + "Aux." ) );
xaod->setStore( aux );
ATH_MSG_INFO( "Recorded ForwardEventInfos with key: " << m_xaodContainerName );
CHECK( m_cnvTool->convert(aod, xaod) );
// Return gracefully - like a elephant on roller skates :
return StatusCode::SUCCESS;
}
} // namespace xAODMaker
// Dear emacs, this is -*- c++ -*-
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
//
#ifndef XAODFORWARDCNV_FORWARDEVENTINFOCNVALG_H
#define XAODFORWARDCNV_FORWARDEVENTINFOCNVALG_H
// System include(s):
#include <string>
// Athena/Gaudi include(s):
#include "AthenaBaseComps/AthAlgorithm.h"
#include "GaudiKernel/ToolHandle.h"
#include "xAODForwardCnv/IForwardEventInfoCnvTool.h"
namespace xAODMaker {
/**
* update for mbts
* @short Algorithm creating xAOD::ForwardEventInfos from TileCellContainer
*
* This algorithm can be used to translate the TileCells coming
* from an AOD, and create xAOD::ForwardEventInfo objects out of them
* for an output xAOD.
*
*
*/
class ForwardEventInfoCnvAlg : public AthAlgorithm {
public:
///@brief Regular algorithm constructor
ForwardEventInfoCnvAlg( const std::string& name, ISvcLocator* svcLoc );
///@brief Function initialising the algorithm
virtual StatusCode initialize();
///@brief Function executing the algorithm
virtual StatusCode execute();
private:
///@brief The key of the input ForwardEventInfoContainer
std::string m_aodContainerName;
///@brief The key for the output xAOD::ForwardEventInfoContainer
std::string m_xaodContainerName;
/** @brief Handle to the converter tool */
ToolHandle<IForwardEventInfoCnvTool> m_cnvTool;
}; // class ForwardEventInfoCnvAlg
} // namespace xAODMaker
#endif // XAODFORWARDCNV_FORWARDEVENTINFOCNVALG_H
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
// Gaudi/Athena include(s):
#include "AthenaKernel/errorcheck.h"
// Old EDM Includes:
#include "TileEvent/MBTSCollisionTime.h"
// New EDM
#include "xAODForward/ForwardEventInfoAuxContainer.h"
// Local include(s):
#include "ForwardEventInfoCnvTool.h"
namespace xAODMaker {
ForwardEventInfoCnvTool::ForwardEventInfoCnvTool(const std::string& type,
const std::string& name,
const IInterface* parent )
: AthAlgTool( type, name, parent ) {
// Declare the interface(s) provided by the tool:
declareInterface< IForwardEventInfoCnvTool >(this);
}
StatusCode ForwardEventInfoCnvTool::initialize() {
ATH_MSG_DEBUG( "Initializing - Package version: " << PACKAGE_VERSION );
// Return gracefully:
return StatusCode::SUCCESS;
}
StatusCode ForwardEventInfoCnvTool::convert( const MBTSCollisionTime* aod,
xAOD::ForwardEventInfoContainer* xaod) const
{
if (!aod) {
ATH_MSG_WARNING("No input ForwardEventInfo Collection passed");
return StatusCode::SUCCESS;
}
// Create the xAOD objects:
xAOD::ForwardEventInfo *xfwinfo = new xAOD::ForwardEventInfo();
xaod->push_back( xfwinfo );
xfwinfo->setTimeDiff(aod->timeA() - aod->timeC());
xfwinfo->setTimeA(aod->timeA());
xfwinfo->setTimeC(aod->timeC());
xfwinfo->setCountA(aod->ncellA());
xfwinfo->setCountC(aod->ncellC());
// Return gracefully:
return StatusCode::SUCCESS;
}
}
// Dear emacs, this is -*- c++ -*-
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
// $Id$
#ifndef XAODFORWARDCNV_FORWARDEVENTINFOCNVTOOL_H
#define XAODFORWARDCNV_FORWARDEVENTINFOCNVTOOL_H
// System include(s):
#include <string>
// Gaudi/Athena include(s):
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ToolHandle.h"
// EDM include(s):
#include "TileEvent/MBTSCollisionTime.h"
#include "xAODForwardCnv/IForwardEventInfoCnvTool.h"
namespace xAODMaker {
/**
* @short Implementation for the tool creating ForwardEventInfoContainer from an AOD
*
* This interface is implemented by the tool that converts the
* egamma (ForwardEventInfo) Container into an xAOD::ForwardEventInfoContainer.
*
* @author Andrzej Zemla <azemla@cern.ch>
*
* $Revision$
* $Date$
*/
class ForwardEventInfoCnvTool : public AthAlgTool,
public virtual IForwardEventInfoCnvTool {
public:
/// Regular AlgTool constructor
ForwardEventInfoCnvTool( const std::string& type, const std::string& name,
const IInterface* parent );
/// Function initializing the tool
virtual StatusCode initialize();
/// Function that fills an existing xAOD::ForwardEventInfoContainer
virtual StatusCode convert( const MBTSCollisionTime* aod,
xAOD::ForwardEventInfoContainer* xaod) const;
}; // class ForwardEventInfoCnvTool
} // namespace xAODMaker
#endif // XAODFORWARDCNV_FORWARDEVENTINFOCNVTOOL_H
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
// Gaudi/Athena include(s):
#include "AthenaKernel/errorcheck.h"
// Old mbts (tile) info!
#include "TileEvent/TileCellContainer.h"
//New egamma
#include "xAODForward/MBTSModuleContainer.h"
#include "xAODForward/MBTSModuleAuxContainer.h"
// Local include(s):
#include "MBTSModuleCnvAlg.h"
namespace xAODMaker {
MBTSModuleCnvAlg::MBTSModuleCnvAlg( const std::string& name,
ISvcLocator* svcLoc )
: AthAlgorithm( name, svcLoc ),m_cnvTool( "xAODMaker::MBTSModuleCnvTool/MBTSModuleCnvTool", this ) {
declareProperty( "AODContainerName", m_aodContainerName = "MBTSContainer" );
declareProperty( "xAODContainerName", m_xaodContainerName = "MBTSModules" );
declareProperty("CnvTool", m_cnvTool, "The converter tool for MBTSModules");
}
StatusCode MBTSModuleCnvAlg::initialize() {
ATH_MSG_INFO( "Initializing - Package version: " << PACKAGE_VERSION );
ATH_MSG_INFO( "AODContainerName = " << m_aodContainerName );
ATH_MSG_INFO( "xAODContainerName = " << m_xaodContainerName );
CHECK(m_cnvTool.retrieve());
// Return gracefully:
return StatusCode::SUCCESS;
}
StatusCode MBTSModuleCnvAlg::execute() {
// Retrieve the AOD particles:
const TileCellContainer* aod = 0;
CHECK( evtStore()->retrieve(aod, m_aodContainerName) );
if (!aod) {
ATH_MSG_WARNING("No MBTSModuleCollection with key " << m_aodContainerName << " found. Do nothing.");
return StatusCode::SUCCESS;
}
ATH_MSG_INFO( "Retrieved particles with key: " << m_aodContainerName );
/////////////////////////////////////////////////////////////////////////////////////////
// Create the xAOD container and its auxiliary store:
xAOD::MBTSModuleContainer* xaod = new xAOD::MBTSModuleContainer();
CHECK( evtStore()->record( xaod, m_xaodContainerName ) );
xAOD::MBTSModuleAuxContainer* aux = new xAOD::MBTSModuleAuxContainer();
CHECK( evtStore()->record( aux, m_xaodContainerName + "Aux." ) );
xaod->setStore( aux );
ATH_MSG_INFO( "Recorded MBTSModules with key: " << m_xaodContainerName );
CHECK( m_cnvTool->convert(aod, xaod) );
// Return gracefully - like a elephant on roller skates :
return StatusCode::SUCCESS;
}
} // namespace xAODMaker
// Dear emacs, this is -*- c++ -*-
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
//
#ifndef XAODFORWARDCNV_MBTSMODULECNVALG_H
#define XAODFORWARDCNV_MBTSMODULECNVALG_H
// System include(s):
#include <string>
// Athena/Gaudi include(s):
#include "AthenaBaseComps/AthAlgorithm.h"
#include "GaudiKernel/ToolHandle.h"
#include "xAODForwardCnv/IMBTSModuleCnvTool.h"
namespace xAODMaker {
/**
* update for mbts
* @short Algorithm creating xAOD::MBTSModules from TileCellContainer
*
* This algorithm can be used to translate the TileCells coming
* from an AOD, and create xAOD::MBTSModule objects out of them
* for an output xAOD.
*
*
*/
class MBTSModuleCnvAlg : public AthAlgorithm {
public:
///@brief Regular algorithm constructor
MBTSModuleCnvAlg( const std::string& name, ISvcLocator* svcLoc );
///@brief Function initialising the algorithm
virtual StatusCode initialize();
///@brief Function executing the algorithm
virtual StatusCode execute();
private:
///@brief The key of the input MBTSModuleContainer
std::string m_aodContainerName;
///@brief The key for the output xAOD::MBTSModuleContainer
std::string m_xaodContainerName;
/** @brief Handle to the converter tool */
ToolHandle<IMBTSModuleCnvTool> m_cnvTool;
}; // class MBTSModuleCnvAlg
} // namespace xAODMaker
#endif // XAODFORWARDCNV_MBTSMODULECNVALG_H
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
// Gaudi/Athena include(s):
#include "AthenaKernel/errorcheck.h"
// Old EDM Includes:
//#include "TileEvent/TileCell.h"
#include "TileIdentifier/TileTBID.h"
#include "TileEvent/TileCellContainer.h"
//New EDM
#include "xAODForward/MBTSModuleAuxContainer.h"
// Local include(s):
#include "MBTSModuleCnvTool.h"
namespace xAODMaker {
MBTSModuleCnvTool::MBTSModuleCnvTool(const std::string& type,
const std::string& name,
const IInterface* parent )
: AthAlgTool( type, name, parent ) {
// Declare the interface(s) provided by the tool:
declareInterface< IMBTSModuleCnvTool >(this);
}
StatusCode MBTSModuleCnvTool::initialize() {
ATH_MSG_DEBUG( "Initializing - Package version: " << PACKAGE_VERSION );
// Return gracefully:
return StatusCode::SUCCESS;
}
StatusCode MBTSModuleCnvTool::convert( const TileCellContainer* aod,
xAOD::MBTSModuleContainer* xaod) const
{
if (!aod) {
ATH_MSG_WARNING("No input MBTSModule Collection passed");
return StatusCode::SUCCESS;
}
// Create the xAOD objects:
const auto end = aod->end();
for(auto itr = aod->begin(); itr != end; ++itr ) {
//fill it here
xAOD::MBTSModule *xmbtsmod = new xAOD::MBTSModule();
xaod->push_back( xmbtsmod );
xmbtsmod->setE((*itr)->energy());
xmbtsmod->setEta((*itr)->eta());
xmbtsmod->setPhi((*itr)->phi());
xmbtsmod->setTime((*itr)->time());
xmbtsmod->setMbtsQuality((*itr)->quality());
const TileTBID* tileid = 0;
CHECK( detStore() -> retrieve(tileid) );
Identifier id = (*itr)->ID();
xmbtsmod->setType(tileid->type(id));
xmbtsmod->setMbtsModule(tileid->module(id));
xmbtsmod->setChannel(tileid->channel(id));
}
// Return gracefully:
return StatusCode::SUCCESS;
}
}
// Dear emacs, this is -*- c++ -*-
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
// $Id$
#ifndef XAODFORWARDCNV_MBTSMODULECNVTOOL_H
#define XAODFORWARDCNV_MBTSMODULECNVTOOL_H
// System include(s):
#include <string>
// Gaudi/Athena include(s):
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ToolHandle.h"
// EDM include(s):
#include "TileEvent/TileCellContainer.h"
#include "xAODForwardCnv/IMBTSModuleCnvTool.h"
namespace xAODMaker {
/**
* @short Implementation for the tool creating MBTSModuleContainer from an AOD
*
* This interface is implemented by the tool that converts the
* egamma (MBTSModule) Container into an xAOD::MBTSModuleContainer.
*
* @author Andrzej Zemla <azemla@cern.ch>
*
* $Revision$
* $Date$
*/
class MBTSModuleCnvTool : public AthAlgTool,
public virtual IMBTSModuleCnvTool {
public:
/// Regular AlgTool constructor
MBTSModuleCnvTool( const std::string& type, const std::string& name,
const IInterface* parent );
/// Function initializing the tool
virtual StatusCode initialize();
/// Function that fills an existing xAOD::MBTSModuleContainer
virtual StatusCode convert( const TileCellContainer* aod,
xAOD::MBTSModuleContainer* xaod) const;
}; // class MBTSModuleCnvTool
} // namespace xAODMaker
#endif // XAODFORWARDCNV_MBTSMODULECNVTOOL_H
// Gaudi/Athena include(s):
#include "GaudiKernel/DeclareFactoryEntries.h"
// Local include(s):
#include "../MBTSModuleCnvAlg.h"
#include "../MBTSModuleCnvTool.h"
#include "../ForwardEventInfoCnvAlg.h"
#include "../ForwardEventInfoCnvTool.h"
DECLARE_NAMESPACE_ALGORITHM_FACTORY( xAODMaker, MBTSModuleCnvAlg )
DECLARE_NAMESPACE_TOOL_FACTORY( xAODMaker, MBTSModuleCnvTool )
DECLARE_NAMESPACE_ALGORITHM_FACTORY( xAODMaker, ForwardEventInfoCnvAlg )
DECLARE_NAMESPACE_TOOL_FACTORY( xAODMaker, ForwardEventInfoCnvTool )
DECLARE_FACTORY_ENTRIES( xAODForwardCnv ) {
DECLARE_NAMESPACE_ALGORITHM( xAODMaker, MBTSModuleCnvAlg )
DECLARE_NAMESPACE_TOOL( xAODMaker, MBTSModuleCnvTool )
DECLARE_NAMESPACE_ALGORITHM( xAODMaker, ForwardEventInfoCnvAlg )
DECLARE_NAMESPACE_TOOL( xAODMaker, ForwardEventInfoCnvTool )
}
#include "GaudiKernel/LoadFactoryEntries.h"
LOAD_FACTORY_ENTRIES(xAODForwardCnv)
// Dear emacs, this is -*- c++ -*-
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
// $Id$
#ifndef XAODFORWARDCNV_IFORWARDEVENTINFOCNVTOOL_H
#define XAODFORWARDCNV_IFORWARDEVENTINFOCNVTOOL_H
// Gaudi/Athena include(s):
#include "GaudiKernel/IAlgTool.h"
//#include "DataModel/DataVector.h"
// EDM include(s):
#include "xAODForward/ForwardEventInfoContainer.h"
//Forward declarations
class MBTSCollisionTime;
namespace xAODMaker {
/// The interface provided by IForwardEventInfoCnvTool
static const InterfaceID
IID_IForwardEventInfoCnvTool( "xAODMaker::IForwardEventInfoCnvTool", 1, 0 );
/**
* @short Interface for the tool creating ForwardEventInfoContainer from an AOD
*
* This interface is implemented by the tool that converts the
* egamma (ForwardEventInfo) Container into an xAOD::ForwardEventInfoContainer.
*
* @author Jovan Mitrevski <Jovan.Mitrevski@cern.ch>
*
* $Revision$
* $Date$
*/
class IForwardEventInfoCnvTool : public virtual IAlgTool {
public:
/// Function that fills an existing xAOD::ForwardEventInfoContainer
virtual StatusCode convert( const MBTSCollisionTime* aod,
xAOD::ForwardEventInfoContainer* xaod) const = 0;
/// Gaudi interface definition
static const InterfaceID& interfaceID() {
return IID_IForwardEventInfoCnvTool;
}
}; // class IForwardEventInfoCnvTool
} // namespace xAODMaker
#endif // XAODFORWARDCNV_IFORWARDEVENTINFOCNVTOOL_H
// Dear emacs, this is -*- c++ -*-
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
// $Id$
#ifndef XAODFORWARDCNV_IMBTSMODULECNVTOOL_H
#define XAODFORWARDCNV_IMBTSMODULECNVTOOL_H
// Gaudi/Athena include(s):
#include "GaudiKernel/IAlgTool.h"
//#include "DataModel/DataVector.h"
// EDM include(s):
#include "xAODForward/MBTSModuleContainer.h"
//Forward declarations
#include "TileEvent/TileContainer.h"
namespace xAODMaker {
/// The interface provided by IMBTSModuleCnvTool
static const InterfaceID
IID_IMBTSModuleCnvTool( "xAODMaker::IMBTSModuleCnvTool", 1, 0 );
/**
* @short Interface for the tool creating MBTSModuleContainer from an AOD
*
* This interface is implemented by the tool that converts the
* egamma (MBTSModule) Container into an xAOD::MBTSModuleContainer.
*
* @author Jovan Mitrevski <Jovan.Mitrevski@cern.ch>
*
* $Revision$
* $Date$
*/
class IMBTSModuleCnvTool : public virtual IAlgTool {
public:
/// Function that fills an existing xAOD::MBTSModuleContainer
virtual StatusCode convert( const TileCellContainer* aod,
xAOD::MBTSModuleContainer* xaod) const = 0;
/// Gaudi interface definition
static const InterfaceID& interfaceID() {
return IID_IMBTSModuleCnvTool;
}
}; // class IMBTSModuleCnvTool
} // namespace xAODMaker
#endif // XAODFORWARDCNV_IMBTSMODULECNVTOOL_H
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment