Skip to content
Snippets Groups Projects
Commit 3bed7719 authored by Graeme Stewart's avatar Graeme Stewart
Browse files

PhysicsAnalysis/D3PDMaker/TrigJetD3PDMaker deleted from 20.11

parent 50de0260
No related branches found
No related tags found
No related merge requests found
Showing
with 0 additions and 890 deletions
include $(CMTROOT)/src/Makefile.header
include $(CMTROOT)/src/constituents.make
package TrigJetD3PDMaker
author Mario Campanelli <Mario.Campanelli@cern.ch>
# Basic Gaudi/Athena package(s):
use AtlasPolicy AtlasPolicy-*
private
use GaudiInterface GaudiInterface-* External
use AthenaKernel AthenaKernel-* Control
use SGTools SGTools-* Control
# D3PD package(s):
use D3PDMakerUtils D3PDMakerUtils-* PhysicsAnalysis/D3PDMaker
use TriggerD3PDMaker TriggerD3PDMaker-* PhysicsAnalysis/D3PDMaker
# EDM package(s):
use EventKernel EventKernel-* Event
use JetEvent JetEvent-* Reconstruction/Jet
use TrigCaloEvent TrigCaloEvent-* Trigger/TrigEvent
use TrigT2CaloJet TrigT2CaloJet-* Trigger/TrigAlgorithms
end_private
library TrigJetD3PDMaker *.cxx components/*.cxx
apply_pattern component_library
apply_pattern declare_python_modules files="*.py"
apply_pattern declare_joboptions files="*.py"
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id: EFJetD3PDObject.py 497739 2012-04-25 18:29:21Z lbeemste $
#
# D3PD object that saves the information about EF jets.
#
from RecExConfig.RecFlags import rec
from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags,_string_prop
import TrigJetD3PDMaker
import EventCommonD3PDMaker
import JetD3PDMaker
EFJetD3PDObject = make_SGDataVector_D3PDObject( 'JetCollection',
'HLT_TrigJetRec',
'trig_EF_jet_',
'EFJetD3PDObject' )
EFJetD3PDObject.defineBlock( 0, 'Kinematics',
EventCommonD3PDMaker.FourMomFillerTool,
WriteE = True )
EFJetD3PDObject.defineBlock( 0, 'EMScale',
JetD3PDMaker.JetSignalStateFillerTool,
WriteE = True,
SignalStateNumber = 0,
SignalStatePrefix = 'emscale' )
EFJetD3PDObject.defineBlock( 0, 'ConstituentScale',
JetD3PDMaker.JetSignalStateFillerTool,
WriteE = True,
SignalStateNumber = 2,
SignalStatePrefix = 'constscale' )
EFJetD3PDObject.defineBlock( 0, 'JetAuthor', JetD3PDMaker.JetAuthorFillerTool, WriteAuthor = True, WriteCalibTags = True)
momlist = []
#DQ based moments
momlist += ['n90', 'Timing', 'LArQuality', 'HECQuality', 'NegativeE', 'fracSamplingMax', 'SamplingMax',
'n90constituents', 'TileQuality', 'hecF','EMFraction','presamplerFraction','AverageLArQF']
#Calib based moments
momlist += ['EMJES', 'EMJES_EtaCorr']
#HI base moments
momlist += ['Discriminant', 'MeanTowerEtUnsubtr']
EFJetD3PDObject.defineBlock( 0, 'JetMoments', JetD3PDMaker.JetMomentFillerTool, Moments = momlist + ['TrigJetFeaturesUnpacker_Status'])
# Set up the object sources in a separate list
# V4 Menu naming convention
# cannot rely on this when chain name contains more than one algorithm tag
# use _calibtag branch (std::string) instead
EFJetObjectSourcesV4 = [ "EF_.*_a2hiem.*", "a2hiem",
"EF_.*_a4hiem.*", "a4hiem",
"EF_.*_a2hihad.*", "a2hihad",
"EF_.*_a4hihad.*", "a4hihad",
"EF_.*_a2tchad.*", "a2tchad",
"EF_.*_a2tcem.*", "a2tcem",
"EF_.*_a4tcem.*", "a4tcem",
"EF_.*_a4tchad.*", "a4tchad",
"EF_.*_a4ttem.*", "a4ttem",
"EF_.*_a4tthad.*", "a4tthad",
"EF_.*_a10tcem.*", "a10tcem",
"EF_.*_a2tclcw.*", "a2tclcw",
"EF_.*_a4tclcw.*", "a4tclcw",
"EF_.*_a10tclcw.*", "a10tclcw",
]
## This is for backwards compatibility, only meaningfull for v3 menus.
EFJetObjectSources = [ "EF_.*_a4tc_EFFS.*", "a4tc",
"EF_.*_a10tc_EFFS.*", "a10tc",
"EF_.*_a2hi_EFFS.*", "a2hi",
]
# This block flags the EF jet objects based on which algorithm was
# used to reconstruct them. One has to find a set of unprescaled trigger chains
# that use one particular reconstruction algorithm, and pair them up with a
# flag name. Unfortunately this does make the configuration a bit trigger
# menu dependent...
EFJetD3PDObject.defineBlock( 2, "Source",
TrigJetD3PDMaker.JetObjectSourceFillerTool,
Sources = EFJetObjectSources )
EFJetD3PDObject.defineBlock( 2, 'JetRoIword',
JetD3PDMaker.JetROIWordFillerTool )
if not hasattr( D3PDMakerFlags, "JetEFTrigPattern" ):
_string_prop( "JetEFTrigPattern", "EF_[2-9]?f?j[0-9]*.*" )
EFJetD3PDObject.defineBlock( 99, 'Triggers',
TrigJetD3PDMaker.JetObjectDecisionFillerTool,
AllowExtend = D3PDMakerFlags.AllowTrigExtend(),
Chains = [ D3PDMakerFlags.JetEFTrigPattern() ] )
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
from TriggerMenuAnalysis.TriggerMenuAnalysisConf import RoILinksCnvTool
import logging
log = logging.getLogger('Setup_RoILinksCnvTool_IBv2.py')
from AthenaCommon.AppMgr import ToolSvc
ToolSvc += RoILinksCnvTool('RoILinksCnvTool')
ToolSvc.RoILinksCnvTool.Chains_Electron = [
'L2_e3_NoCut', 'EF_e3_NoCut',
'L2_e3_NoCut_IdScan', 'EF_e3_NoCut_IdScan',
'L2_e3_NoCut_TRT', 'EF_e3_NoCut_TRT',
'L2_e5_NoCut_cells', 'EF_e5_NoCut_cells',
'L2_e5_NoCut','EF_e5_NoCut',
'L2_e5_NoCut_SiTrk', 'EF_e5_NoCut_SiTrk',
'L2_e5_NoCut_IdScan', 'EF_e5_NoCut_IdScan',
'L2_e5_NoCut_TRT', 'EF_e5_NoCut_TRT',
'L2_e5_NoCut_FwdBackTrk', 'EF_e5_NoCut_FwdBackTrk',
'L2_e5_loose', 'EF_e5_loose',
'L2_e5_loose_IdScan', 'EF_e5_loose_IdScan',
'L2_e5_loose_TRT', 'EF_e5_loose_TRT',
'L2_e10_loose', 'EF_e10_loose',
'L2_e10_loose_passL2', 'EF_e10_loose_passL2',
'L2_e10_loose_passEF', 'EF_e10_loose_passEF',
'L2_e10_medium', 'EF_e10_medium',
'L2_g3_nocut', 'EF_g3_nocut',
'L2_g5_nocut', 'EF_g5_nocut',
'L2_g5_loose', 'EF_g5_loose',
'L2_g10_loose', 'EF_g10_loose',
#ID monitoring
'L2_e5_loose_NoIDTrkCut', 'EF_e5_loose_NoIDTrkCut',
'L2_e20_loose_NoIDTrkCut', 'EF_e20_loose_NoIDTrkCut',
]
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id: Setup_RoILinksCnvTool_IBv3.py 307763 2010-06-29 14:25:58Z krasznaa $
#
# Code setting up which HLT chains to save navigation information about.
#
from AthenaCommon.AppMgr import ToolSvc
if not hasattr( ToolSvc, "RoILinksCnvTool" ):
from TriggerMenuAnalysis.TriggerMenuAnalysisConf import RoILinksCnvTool
ToolSvc += RoILinksCnvTool( "RoILinksCnvTool" )
ToolSvc.RoILinksCnvTool.Chains_Jet = [
"L2_j7", "EF_j10v3",
"L2_j15", "EF_j20v2",
"L2_j30", "EF_j40",
"L2_j60", "EF_j80v2",
"L2_j90", "EF_j140",
"L2_j130", "EF_j200",
]
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id: TrigJetD3PD.py 491506 2012-03-29 08:55:23Z krasznaa $
#
# Set up the trigger navigation flattening for the jet chains. Done ins the
# same wat as it was done for the egammaD3PD...
#
from AthenaCommon.AlgSequence import AlgSequence
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
from D3PDMakerCoreComps.D3PDObject import make_Void_D3PDObject
InitTrigD3PDObject = make_Void_D3PDObject( default_name = 'InitTrig' )
def _initTrigHook( c, **kw ):
import TrigJetD3PDMaker.Setup_RoILinksCnvTool_IBv3
preseq = AlgSequence( D3PDMakerFlags.PreD3PDAlgSeqName() )
if not hasattr( preseq, 'FlatHltNaviMaker' ):
from TriggerMenuAnalysis.TriggerMenuAnalysisConf import FlatHltNaviMaker
preseq += FlatHltNaviMaker( 'FlatHltNaviMaker' )
return
InitTrigD3PDObject.defineHook( _initTrigHook )
##
# @short Function for passing parameters to individual D3PDObjects
#
# This function helps in making it possible to pass specific options
# to the D3PDObjects added by the TrigEgammaD3PDObjects function.
# The formalist is the same as for all the other D3PDMaker function.
#
# @param level The overall detail level of the D3PDObject
# @param name An object name to refer to this object later on
# @param kwin Input keyworded parameters
# @param kw Extra keywords provided here
# @returns The list of parameters to give to the D3PDObject
#
def _args( level, name, kwin, **kw ):
result = kw.copy()
result[ "level" ] = level
for ( k, v ) in kwin.items():
if k.startswith( name + "_" ):
result[ k[ len( name ) + 1 : ] ] = v
pass
pass
return result
## Function adding the full jet trigger information to a D3PD
#
# This function can be used to add jet trigger information from all the trigger levels
# to a D3PD. By default the function adds the jet trigger information with the
# highest detail level. This can be modified by changing the "level" parameter to a
# lower value, and/or turning off the "addNaviInfo" and "addConfigInfo" parameters.
#
def TrigJetD3PDObjects( alg, level = 10, addNaviInfo = True, addConfigInfo = True, **kw ):
#
# Configure the navigation flattening if it's requested:
#
if addNaviInfo:
alg += InitTrigD3PDObject( level )
#
# Add the LVL1 information if it's not added yet:
#
if not hasattr( alg, "trig_L1_jet_Filler" ):
from TriggerD3PDMaker.JetROID3PDObject import JetROID3PDObject
alg += JetROID3PDObject( **_args( level, "JetRoI", kw ) )
pass
#
# Add the LVL2 information:
#
from TrigJetD3PDMaker.TrigJetD3PDObject import TrigJetD3PDObject
alg += TrigJetD3PDObject( **_args( level, "L2Jet", kw ) )
#
# Add the EF information:
#
from TrigJetD3PDMaker.EFJetD3PDObject import EFJetD3PDObject
alg += EFJetD3PDObject( **_args( level, "EFJet", kw ) )
#
# Trigger navigation info:
#
if addNaviInfo:
from TriggerD3PDMaker.TrigNaviD3PDObject import \
ChainEntryD3PDObject, CombLinksD3PDObjects
if not hasattr( alg, "trig_Nav_Filler" ):
alg += ChainEntryD3PDObject( **_args( level, "ChainEntry", kw ) )
pass
alg += CombLinksD3PDObjects[ 'L2_j' ]( **_args( level, "CombLinksL2", kw ) )
alg += CombLinksD3PDObjects[ 'EF_j' ]( **_args( level, "CombLinksEF", kw ) )
pass
# Add the trigger configuration metadata:
if addConfigInfo:
from TriggerD3PDMaker.TrigConfMetadata import addTrigConfMetadata
addTrigConfMetadata( alg )
return alg
def TrigJetD3PD( fname, level=10, tname='trigjet', seq = AlgSequence() ):
import D3PDMakerCoreComps
alg = D3PDMakerCoreComps.MakerAlg( tname, seq = seq, file = fname )
TrigJetD3PDObjects( alg, level )
return alg
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id: TrigJetD3PDObject.py 488065 2012-03-12 17:10:31Z chapleau $
#
# D3PD object saving information about the LVL2 TrigJet objects
#
from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags,_string_prop
import EventCommonD3PDMaker
import TrigJetD3PDMaker
TrigJetContainer_sgkey = 'HLT_TrigT2CaloJet'
TrigJetD3PDObject = make_SGDataVector_D3PDObject( 'TrigT2JetContainer',
TrigJetContainer_sgkey,
'trig_L2_jet_',
'TrigJetD3PDObject' )
# Level 0
TrigJetD3PDObject.defineBlock( 0, 'Kinematics',
EventCommonD3PDMaker.FourMomFillerTool,
WriteE = True,
WritePt = False,
WriteM = False )
TrigJetD3PDObject.defineBlock( 0, 'Basics',
TrigJetD3PDMaker.TrigT2JetFillerTool,
WriteBasics = True )
# Set up the object sources in a separate list
# V4 Menu naming convention. Regular Cone jets only
L2JetObjectSources = [ "L2_.*_c4cchad.*", "c4cchad",
"L2_.*_c4ccem.*", "c4ccem",
"L2_.*_c4uchad.*", "c4uchad",
]
# This block flags the L2 jet objects based on which algorithm was
# used to reconstruct them. One has to find a set of unprescaled trigger chains
# that use one particular reconstruction algorithm, and pair them up with a
# flag name. Unfortunately this does make the configuration a bit trigger
# menu dependent...
TrigJetD3PDObject.defineBlock( 0, 'Source',
TrigJetD3PDMaker.TrigT2JetObjectSourceFillerTool,
Sources = L2JetObjectSources )
# Level 1
TrigJetD3PDObject.defineBlock( 1, 'Details',
TrigJetD3PDMaker.TrigT2JetFillerTool,
WriteDetails = True )
# Level 2
TrigJetD3PDObject.defineBlock( 1, 'Cleaning',
TrigJetD3PDMaker.TrigT2JetFillerTool,
WriteCleaning = True )
if not hasattr( D3PDMakerFlags, "JetL2TrigPattern" ):
_string_prop( "JetL2TrigPattern", "L2_[2-9]?f?j[0-9]*.*" )
TrigJetD3PDObject.defineBlock( 99, "Decision",
TrigJetD3PDMaker.TrigT2JetObjectDecisionFillerTool,
AllowExtend = D3PDMakerFlags.AllowTrigExtend(),
Chains = [ D3PDMakerFlags.JetL2TrigPattern() ] )
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id: __init__.py 307763 2010-06-29 14:25:58Z krasznaa $
#
# @file TrigJetD3PDMaker/python/__init__.py
# @author scott snyder <snyder@bnl.gov>
# @date Sep, 2009
# @brief Define shortcuts for referencing configurables in this package.
#
# With this, instead of writing
#
# TrigJetD3PDMaker.TrigJetD3PDMakerConf.D3PD__TrigElectronFillerTool
#
# we can write
#
# TrigJetD3PDMaker.TrigElectronFillerTool
#
import TrigJetD3PDMakerConf
for k, v in TrigJetD3PDMakerConf.__dict__.items():
if k.startswith ('D3PD__'):
globals()[k[6:]] = v
# $Id: makeTrigJetD3PD.py 307763 2010-06-29 14:25:58Z krasznaa $
#
# Example jobO for saving the full trigger jet information from an ESD/AOD file.
#
# Properties that the users should modify:
if not "InputFiles" in dir():
InputFiles = [ "AOD.pool.root" ]
if not "level" in dir():
level = 10
if not "OutputFile" in dir():
OutputFile = "trig_jet_d3pd_level%d.root" % level
if not "EvtMax" in dir():
EvtMax = 100
# Set up the needed RecEx flags:
from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
athenaCommonFlags.FilesInput.set_Value_and_Lock( InputFiles )
athenaCommonFlags.EvtMax.set_Value_and_Lock( EvtMax )
# Set up what the RecExCommon job should and shouldn't do:
from RecExConfig.RecFlags import rec
rec.AutoConfiguration = [ "everything" ]
rec.doCBNT.set_Value_and_Lock( False )
rec.doWriteESD.set_Value_and_Lock( False )
rec.doWriteAOD.set_Value_and_Lock( False )
rec.doWriteTAG.set_Value_and_Lock( False )
rec.doESD.set_Value_and_Lock( False )
rec.doAOD.set_Value_and_Lock( False )
rec.doDPD.set_Value_and_Lock( False )
rec.doHist.set_Value_and_Lock( False )
rec.doPerfMon.set_Value_and_Lock( False )
rec.doForwardDet.set_Value_and_Lock( False )
# Let RecExCommon set everything up:
include( "RecExCommon/RecExCommon_topOptions.py" )
#########################################################################
# #
# Now set up the D3PDMaker job #
# #
#########################################################################
# Create a logger, mainly for fun:
from AthenaCommon.Logging import logging
logger = logging.getLogger( "makeTrigJetD3PD" )
# Access the algorithm sequence:
from AthenaCommon.AlgSequence import AlgSequence
theJob = AlgSequence()
# Save the full trigger jet information:
from TrigJetD3PDMaker.TrigJetD3PD import TrigJetD3PD
d3pdalg = TrigJetD3PD( OutputFile, level = level )
# Add some basic event-level information:
from EventCommonD3PDMaker.EventInfoD3PDObject import EventInfoD3PDObject
d3pdalg += EventInfoD3PDObject( 1 )
logger.info( "Configured the D3PDMaker algorithm" )
# Do some of the additional setup:
from AthenaCommon.AppMgr import theApp
theApp.EvtMax = athenaCommonFlags.EvtMax()
ServiceMgr.MessageSvc.OutputLevel = INFO
ServiceMgr.MessageSvc.defaultLimit = 10000000
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
// $Id: JetObjectDecisionFillerTool.cxx 307763 2010-06-29 14:25:58Z krasznaa $
// Local include(s):
#include "JetObjectDecisionFillerTool.h"
namespace D3PD {
JetObjectDecisionFillerTool::JetObjectDecisionFillerTool( const std::string& type,
const std::string& name,
const IInterface* parent )
: TriggerObjectDecisionFillerTool< Jet >( type, name, parent ) {
}
} // namespace D3PD
// Dear emacs, this is -*- c++ -*-
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
// $Id: JetObjectDecisionFillerTool.h 307763 2010-06-29 14:25:58Z krasznaa $
#ifndef TRIGJETD3PDMAKER_JETOBJECTDECISIONFILLERTOOL_H
#define TRIGJETD3PDMAKER_JETOBJECTDECISIONFILLERTOOL_H
// EDM include(s):
#include "JetEvent/Jet.h"
// D3PDMaker include(s):
#include "TriggerD3PDMaker/TriggerObjectDecisionFillerTool.h"
namespace D3PD {
/**
* @short Tool recording which chains a Jet object passed
*
* $Revision: 307763 $
* $Date: 2010-06-29 16:25:58 +0200 (Tue, 29 Jun 2010) $
*/
class JetObjectDecisionFillerTool :
public TriggerObjectDecisionFillerTool< Jet > {
public:
/// Regular AlgTool constructor
JetObjectDecisionFillerTool( const std::string& type,
const std::string& name,
const IInterface* parent );
}; // class JetObjectDecisionFillerTool
} // namespace D3PD
#endif // TRIGJETD3PDMAKER_JETOBJECTDECISIONFILLERTOOL_H
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
// $Id: JetObjectSourceFillerTool.cxx 358948 2011-04-15 09:05:30Z krasznaa $
// Local include(s):
#include "JetObjectSourceFillerTool.h"
namespace D3PD {
JetObjectSourceFillerTool::JetObjectSourceFillerTool( const std::string& type,
const std::string& name,
const IInterface* parent )
: TriggerObjectSourceFillerTool< Jet >( type, name, parent ) {
}
} // namespace D3PD
// Dear emacs, this is -*- c++ -*-
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
// $Id: JetObjectSourceFillerTool.h 358948 2011-04-15 09:05:30Z krasznaa $
#ifndef TRIGJETD3PDMAKER_JETOBJECTSOURCEFILLERTOOL_H
#define TRIGJETD3PDMAKER_JETOBJECTSOURCEFILLERTOOL_H
// EDM include(s):
#include "JetEvent/Jet.h"
// D3PDMaker include(s):
#include "TriggerD3PDMaker/TriggerObjectSourceFillerTool.h"
namespace D3PD {
/**
* @short Tool for flagging EF jets based on their "source"
*
* This tool can be used to attach flags to the EF jet
* objects based on which algorithm they were reconstructed
* with. See the documentation of the base class for more
* details.
*
* @author Attila Krasznahroay <Attila.Krasznahorkay@cern.ch>
*
* $Revision: 358948 $
* $Date: 2011-04-15 11:05:30 +0200 (Fri, 15 Apr 2011) $
*/
class JetObjectSourceFillerTool :
public TriggerObjectSourceFillerTool< Jet > {
public:
/// Regular AlgTool constructor
JetObjectSourceFillerTool( const std::string& type,
const std::string& name,
const IInterface* parent );
}; // class JetObjectSourceFillerTool
} // namespace D3PD
#endif // TRIGJETD3PDMAKER_JETOBJECTSOURCEFILLERTOOL_H
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
/*
TrigT2JetFillerTool.cxx
*/
#include "TrigT2JetFillerTool.h"
#include "AthenaKernel/errorcheck.h"
#include "TrigT2CaloJet/T2L1Tools.h"
namespace D3PD {
TrigT2JetFillerTool::TrigT2JetFillerTool( const std::string& type,
const std::string& name,
const IInterface* parent )
: BlockFillerTool< TrigT2Jet >( type, name, parent )
{
// Avoid coverity warnings.
m_writeBasics = true;
m_writeDetails = true;
m_writeCleaning = true;
book().ignore();
declareProperty( "WriteBasics", m_writeBasics = false,
"Write basic information" );
declareProperty("WriteDetails", m_writeDetails = false,
"Write detailed variables" );
declareProperty("WriteCleaning", m_writeCleaning = false,
"Write cleaning variables" );
}
StatusCode TrigT2JetFillerTool::book() {
if( m_writeBasics ) {
CHECK(addVariable("RoIWord", m_roiWord));
CHECK(addVariable("InputType", m_inputType));
CHECK(addVariable("OutputType", m_outputType));
CHECK(addVariable("counter", m_counter));
}
if( m_writeDetails ) {
CHECK(addVariable("ehad0", m_ehad0));
CHECK(addVariable("eem0", m_eem0));
}
if( m_writeCleaning ){
CHECK(addVariable("nLeadingCells", m_nLeadingCells));
CHECK(addVariable("hecf", m_hecf));
CHECK(addVariable("jetQuality", m_jetQuality));
CHECK(addVariable("emf", m_emf));
CHECK(addVariable("jetTimeCells", m_jetTimeCells));
}
return StatusCode::SUCCESS;
}
StatusCode TrigT2JetFillerTool::fill( const TrigT2Jet& x ) {
if( m_writeBasics ) {
*m_roiWord = x.RoIword();
*m_inputType = "";
*m_outputType = "";
*m_counter = -1;
T2L1Tools m_t2l1_tools;
m_t2l1_tools.RoIWordToStrings(x.RoIword(), *m_inputType, *m_outputType, *m_counter);
}
if( m_writeDetails ) {
*m_ehad0 = x.ehad0();
*m_eem0 = x.eem0();
}
if( m_writeCleaning ){
*m_nLeadingCells = x.nLeadingCells();
*m_hecf = x.hecf();
*m_jetQuality = x.jetQuality();
*m_emf = x.emf();
*m_jetTimeCells = x.jetTimeCells();
}
return StatusCode::SUCCESS;
}
}
// Dear emacs, this is -*- c++ -*-
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
// $Id: TrigT2JetFillerTool.h 486968 2012-03-06 20:40:16Z chapleau $
#ifndef __D3PD_TrigT2JetFillerTool_h__
#define __D3PD_TrigT2JetFillerTool_h__
/*
D3PD::TrigT2JetFillerToo.h
*/
#include "D3PDMakerUtils/BlockFillerTool.h"
#include "TrigCaloEvent/TrigT2Jet.h"
namespace D3PD {
/**
* @short Tool saving the properties of TrigT2Jet objects
*
* @author John Morris <john.morris@cern.ch>
* 17/5/2010
*
*/
class TrigT2JetFillerTool : public BlockFillerTool< TrigT2Jet > {
public:
/// Regular AlgTool constructor
TrigT2JetFillerTool( const std::string& type, const std::string& name,
const IInterface* parent);
/// Function booking the variables
StatusCode book();
/// Function filling the variables
StatusCode fill( const TrigT2Jet& x );
private:
// Properties
bool m_writeBasics; ///< Write basic information about the object
bool m_writeDetails; ///< Write detailed information
bool m_writeCleaning; ///< Write cleaning variables
// D3PD variables
/** Internal RoI index to which this object belongs */
uint32_t* m_roiWord;
/** Hadronic Jet Energy before calibration */
double *m_ehad0;
/** Electromagnetic Jet Energy before calibration */
double *m_eem0;
/** number of leading cells */
int *m_nLeadingCells;
/** Fraction of energy in HEC */
float *m_hecf;
/** fraction of jet energy from bad cells */
float *m_jetQuality;
/** Fraction of energy in EMC*/
float *m_emf;
/** Jet time */
float *m_jetTimeCells;
// input type
std::string * m_inputType;
// output type
std::string * m_outputType;
//counter
int * m_counter;
}; // class TrigT2JetFillerTool
} // namespace D3PD
#endif // __D3PD_TrigT2JetFillerTool_h__
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
// $Id: TrigT2JetObjectDecisionFillerTool.cxx 307763 2010-06-29 14:25:58Z krasznaa $
/**
* @file TrigEgammaD3PDMaker/src/TrigT2JetObjectDecisionFillerTool.cxx
* @author scott snyder <snyder@bnl.gov>
* @date Apr, 2010
* @brief Record which triggers are passed by a L2 jet object.
*/
#include "TrigT2JetObjectDecisionFillerTool.h"
#include "TrigCaloEvent/TrigT2Jet.h"
namespace D3PD {
/**
* @brief Standard Gaudi tool constructor.
* @param type The name of the tool type.
* @param name The tool name.
* @param parent The tool's Gaudi parent.
*/
TrigT2JetObjectDecisionFillerTool::TrigT2JetObjectDecisionFillerTool
(const std::string& type,
const std::string& name,
const IInterface* parent)
: TriggerObjectDecisionFillerTool<TrigT2Jet> (type, name, parent)
{
}
} // namespace D3PD
// This file's extension implies that it's C, but it's really -*- C++ -*-.
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
// $Id: TrigT2JetObjectDecisionFillerTool.h 307763 2010-06-29 14:25:58Z krasznaa $
/**
* @file TrigEgammaD3PDMaker/src/TrigT2JetObjectDecisionFillerTool.h
* @author scott snyder <snyder@bnl.gov>
* @date Apr, 2010
* @brief Record which triggers are passed by a L2 jet object.
*/
#ifndef TRIGJETD3PDMAKER_TRIGT2JETOBJECTDECISIONFILLERTOOL_H
#define TRIGJETD3PDMAKER_TRIGT2JETOBJECTDECISIONFILLERTOOL_H
#include "TriggerD3PDMaker/TriggerObjectDecisionFillerTool.h"
class TrigT2Jet;
namespace D3PD {
/**
* @brief Record which triggers are passed by a L2 electron object.
*/
class TrigT2JetObjectDecisionFillerTool
: public TriggerObjectDecisionFillerTool<TrigT2Jet>
{
public:
/**
* @brief Standard Gaudi tool constructor.
* @param type The name of the tool type.
* @param name The tool name.
* @param parent The tool's Gaudi parent.
*/
TrigT2JetObjectDecisionFillerTool (const std::string& type,
const std::string& name,
const IInterface* parent);
};
} // namespace D3PD
#endif
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
// Local include(s):
#include "TrigT2JetObjectSourceFillerTool.h"
namespace D3PD {
TrigT2JetObjectSourceFillerTool::TrigT2JetObjectSourceFillerTool( const std::string& type,
const std::string& name,
const IInterface* parent )
: TriggerObjectSourceFillerTool< TrigT2Jet >( type, name, parent ) {
}
} // namespace D3PD
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
#ifndef TRIGJETD3PDMAKER_TRIGT2JETOBJECTSOURCEFILLERTOOL_H
#define TRIGJETD3PDMAKER_TRIGT2JETOBJECTSOURCEFILLERTOOL_H
// EDM include(s):
#include "TrigCaloEvent/TrigT2Jet.h"
// D3PDMaker include(s):
#include "TriggerD3PDMaker/TriggerObjectSourceFillerTool.h"
namespace D3PD {
/**
* @short Tool for flagging EF jets based on their "source"
*
* This tool can be used to attach flags to the TrigT2Jet
* objects based on which algorithm they were reconstructed
* with. See the documentation of the base class for more
* details.
*/
class TrigT2JetObjectSourceFillerTool :
public TriggerObjectSourceFillerTool< TrigT2Jet > {
public:
/// Regular AlgTool constructor
TrigT2JetObjectSourceFillerTool( const std::string& type,
const std::string& name,
const IInterface* parent );
}; // class TrigT2JetObjectSourceFillerTool
} // namespace D3PD
#endif // TRIGJETD3PDMAKER_TRIGT2JETOBJECTSOURCEFILLERTOOL_H
/*
TrigJetD3PDMaker_entries.cxx
*/
#include "GaudiKernel/DeclareFactoryEntries.h"
#include "../TrigT2JetFillerTool.h"
#include "../TrigT2JetObjectDecisionFillerTool.h"
#include "../JetObjectDecisionFillerTool.h"
#include "../JetObjectSourceFillerTool.h"
#include "../TrigT2JetObjectSourceFillerTool.h"
DECLARE_NAMESPACE_TOOL_FACTORY( D3PD, TrigT2JetFillerTool )
DECLARE_NAMESPACE_TOOL_FACTORY( D3PD, TrigT2JetObjectDecisionFillerTool )
DECLARE_NAMESPACE_TOOL_FACTORY( D3PD, JetObjectDecisionFillerTool )
DECLARE_NAMESPACE_TOOL_FACTORY( D3PD, JetObjectSourceFillerTool )
DECLARE_NAMESPACE_TOOL_FACTORY( D3PD, TrigT2JetObjectSourceFillerTool )
DECLARE_FACTORY_ENTRIES(TrigJetD3PDMaker) {
DECLARE_NAMESPACE_TOOL( D3PD, TrigT2JetFillerTool )
DECLARE_NAMESPACE_TOOL( D3PD, TrigT2JetObjectDecisionFillerTool )
DECLARE_NAMESPACE_TOOL( D3PD, JetObjectDecisionFillerTool )
DECLARE_NAMESPACE_TOOL( D3PD, JetObjectSourceFillerTool )
DECLARE_NAMESPACE_TOOL( D3PD, TrigT2JetObjectSourceFillerTool )
}
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