Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2024-11-27 03:18:00

0001 from builtins import range
0002 from PhysicsTools.PatAlgos.tools.ConfigToolBase import *
0003 
0004 from PhysicsTools.PatAlgos.tools.helpers import *
0005 from PhysicsTools.PatAlgos.patEventContent_cff import patTriggerL1RefsEventContent
0006 
0007 from PhysicsTools.PatAlgos.triggerLayer1.triggerMatcherExamples_cfi import _exampleTriggerMatchers
0008 _defaultTriggerProducer      = 'patTrigger'
0009 _defaultTriggerEventProducer = 'patTriggerEvent'
0010 _defaultPath                 = ''
0011 _defaultHltProcess           = 'HLT'
0012 _defaultOutputModule         = 'out'
0013 _defaultPostfix              = ''
0014 
0015 _defaultTriggerMatchersComment      = "Trigger matcher modules' labels, default: ..."
0016 _defaultTriggerProducerComment      = "PATTriggerProducer module label, default: %s"%( _defaultTriggerProducer )
0017 _defaultTriggerEventProducerComment = "PATTriggerEventProducer module label, default: %s"%( _defaultTriggerEventProducer )
0018 _defaultPathComment                 = "Name of path to use, default: %s"%( _defaultPath )
0019 _defaultHltProcessComment           = "HLT process name, default: %s"%( _defaultHltProcess )
0020 _defaultOutputModuleComment         = "Output module label, empty label indicates no output, default: %s"%( _defaultOutputModule )
0021 _defaultPostfixComment              = "Postfix to apply to PAT module labels, default: %s"%( _defaultPostfix )
0022 
0023 _longLine = '---------------------------------------------------------------------'
0024 
0025 
0026 def _modulesInPath( process, pathLabel ):
0027     return [ m.label() for m in listModules( getattr( process, pathLabel ) ) ]
0028 
0029 
0030 def _addEventContent( outputCommands, eventContent ):
0031     # add new entry to event content
0032     for content in eventContent:
0033         if content not in outputCommands:
0034             outputCommands += [ content ]
0035     # check for obsolete entries
0036     listToRemove = []
0037     for i in range( len( outputCommands ) ):
0038         if i in listToRemove:
0039             continue
0040         command = outputCommands[ i ]
0041         if command[ : 4 ] == 'keep':
0042             dropCommand = command.replace( 'keep ', 'drop ' )
0043             for j in range( i + 1, len( outputCommands ) ):
0044                 testCommand = outputCommands[ j ]
0045                 if testCommand == command:
0046                     listToRemove += [ j ]
0047                 elif testCommand == dropCommand:
0048                     listToRemove += [ i, j ]
0049                     break
0050     # copy entries excl. obsolete ones
0051     newOutputCommands = cms.untracked.vstring()
0052     for i in range( len( outputCommands ) ):
0053         if i not in listToRemove:
0054             newOutputCommands += [ outputCommands[ i ] ]
0055     # return result
0056     return newOutputCommands
0057 
0058 
0059 class SwitchOnTrigger( ConfigToolBase ):
0060     """  Enables trigger information in PAT
0061     SwitchOnTrigger( [cms.Process], triggerProducer = 'patTrigger', triggerEventProducer = 'patTriggerEvent', path = '', hltProcess = 'HLT', outputModule = 'out' )
0062     - [cms.Process]       : the 'cms.Process'
0063     - triggerProducer     : PATTriggerProducer module label;
0064                             optional, default: 'patTrigger'
0065     - triggerEventProducer: PATTriggerEventProducer module label;
0066                             optional, default: 'patTriggerEvent'
0067     - path                : name of path to use;
0068                             optional, default: ''
0069     - hltProcess          : HLT process name;
0070                             optional, default: 'HLT'
0071     - outputModule        : output module label;
0072                             empty label indicates no output;
0073                             optional, default: 'out'
0074     Using None as any argument restores its default value.
0075     """
0076     _label             = 'switchOnTrigger'
0077     _defaultParameters = dicttypes.SortedKeysDict()
0078 
0079     def __init__( self ):
0080         ConfigToolBase.__init__( self )
0081         self.addParameter( self._defaultParameters, 'triggerProducer'     , _defaultTriggerProducer     , _defaultTriggerProducerComment )
0082         self.addParameter( self._defaultParameters, 'triggerEventProducer', _defaultTriggerEventProducer, _defaultTriggerEventProducerComment )
0083         self.addParameter( self._defaultParameters, 'path'                , _defaultPath                , _defaultPathComment )
0084         self.addParameter( self._defaultParameters, 'hltProcess'          , _defaultHltProcess          , _defaultHltProcessComment )
0085         self.addParameter( self._defaultParameters, 'outputModule'        , _defaultOutputModule        , _defaultOutputModuleComment )
0086         self._parameters = copy.deepcopy( self._defaultParameters )
0087         self._comment = ""
0088 
0089     def getDefaultParameters( self ):
0090         return self._defaultParameters
0091 
0092     def __call__( self, process
0093                 , triggerProducer      = None
0094                 , triggerEventProducer = None
0095                 , path                 = None
0096                 , hltProcess           = None
0097                 , outputModule         = None
0098                 ):
0099         if triggerProducer is None:
0100             triggerProducer = self._defaultParameters[ 'triggerProducer' ].value
0101         if triggerEventProducer is None:
0102             triggerEventProducer = self._defaultParameters[ 'triggerEventProducer' ].value
0103         if path is None:
0104             path = self._defaultParameters[ 'path' ].value
0105         if hltProcess is None:
0106             hltProcess = self._defaultParameters[ 'hltProcess' ].value
0107         if outputModule is None:
0108             outputModule = self._defaultParameters[ 'outputModule' ].value
0109         self.setParameter( 'triggerProducer'     , triggerProducer )
0110         self.setParameter( 'triggerEventProducer', triggerEventProducer )
0111         self.setParameter( 'path'                , path )
0112         self.setParameter( 'hltProcess'          , hltProcess )
0113         self.setParameter( 'outputModule'        , outputModule )
0114         self.apply( process )
0115 
0116     def toolCode( self, process ):
0117         triggerProducer      = self._parameters[ 'triggerProducer' ].value
0118         triggerEventProducer = self._parameters[ 'triggerEventProducer' ].value
0119         path                 = self._parameters[ 'path' ].value
0120         hltProcess           = self._parameters[ 'hltProcess' ].value
0121         outputModule         = self._parameters[ 'outputModule' ].value
0122 
0123         task = getPatAlgosToolsTask(process)
0124 
0125         # Load default producers from existing config files, if needed
0126         if not hasattr( process, triggerProducer ):
0127             from PhysicsTools.PatAlgos.triggerLayer1.triggerProducer_cfi import patTrigger
0128             addToProcessAndTask(triggerProducer, patTrigger.clone(), process, task)
0129         else:
0130             print('%s():'%( self._label ))
0131             print('    PATTriggerProducer module \'%s\' exists already in process'%( triggerProducer ))
0132             print('    ==> entry re-used')
0133             print(_longLine)
0134         if not hasattr( process, triggerEventProducer ):
0135             from PhysicsTools.PatAlgos.triggerLayer1.triggerEventProducer_cfi import patTriggerEvent
0136             addToProcessAndTask(triggerEventProducer, patTriggerEvent.clone(), process, task)
0137         else:
0138             print('%s():'%( self._label ))
0139             print('    PATTriggerEventProducer module \'%s\' exists already in process'%( triggerEventProducer ))
0140             print('    ==> entry re-used')
0141             print(_longLine)
0142 
0143         # Maintain configurations
0144         trigProdMod             = getattr( process, triggerProducer )
0145         trigProdMod.processName = hltProcess
0146         if trigProdMod.onlyStandAlone.value() is True:
0147             trigProdMod.onlyStandAlone = False
0148             print('    configuration parameter automatically changed')
0149             print('    PATTriggerProducer %s.onlyStandAlone --> %s'%( triggerProducer, trigProdMod.onlyStandAlone ))
0150             print(_longLine)
0151         trigEvtProdMod                    = getattr( process, triggerEventProducer )
0152         trigEvtProdMod.processName        = hltProcess
0153         trigEvtProdMod.patTriggerProducer = cms.InputTag( triggerProducer )
0154         if path != '':
0155             if not hasattr( process, path ):
0156                 prodPath = cms.Path( trigProdMod + trigEvtProdMod )
0157                 setattr( process, path, prodPath )
0158                 print('%s():'%( self._label ))
0159                 print('    Path \'%s\' does not exist in process'%( path ))
0160                 print('    ==> created')
0161                 print(_longLine)
0162             # Try to get the order right, but cannot deal with all possible cases.
0163             # Simply rely on the exclusive usage of these tools without manual intervention.
0164             else:
0165                 if not triggerProducer in _modulesInPath( process, path ):
0166                     prodPath = getattr( process, path )
0167                     prodPath += trigProdMod
0168                 if not triggerEventProducer in _modulesInPath( process, path ):
0169                     prodPath = getattr( process, path )
0170                     prodPath += trigEvtProdMod
0171 
0172         # Add event content
0173         if outputModule != '':
0174             patTriggerEventContent = [ 'keep patTriggerObjects_%s_*_%s'%( triggerProducer, process.name_() )
0175                                      , 'keep patTriggerFilters_%s_*_%s'%( triggerProducer, process.name_() )
0176                                      , 'keep patTriggerPaths_%s_*_%s'%( triggerProducer, process.name_() )
0177                                      , 'keep patTriggerEvent_%s_*_%s'%( triggerEventProducer, process.name_() )
0178                                      ]
0179             if ( hasattr( trigProdMod, 'addL1Algos' ) and trigProdMod.addL1Algos.value() is True ):
0180                 patTriggerEventContent += [ 'keep patTriggerConditions_%s_*_%s'%( triggerProducer, process.name_() )
0181                                           , 'keep patTriggerAlgorithms_%s_*_%s'%( triggerProducer, process.name_() )
0182                                           ]
0183             if ( hasattr( trigProdMod, 'saveL1Refs' ) and trigProdMod.saveL1Refs.value() is True ):
0184                 patTriggerEventContent += patTriggerL1RefsEventContent
0185             getattr( process, outputModule ).outputCommands = _addEventContent( getattr( process, outputModule ).outputCommands, patTriggerEventContent )
0186 
0187 switchOnTrigger = SwitchOnTrigger()
0188 
0189 
0190 class SwitchOnTriggerStandAlone( ConfigToolBase ):
0191     """  Enables trigger information in PAT, limited to stand-alone trigger objects
0192     SwitchOnTriggerStandAlone( [cms.Process], triggerProducer = 'patTrigger', path = '', hltProcess = 'HLT', outputModule = 'out' )
0193     - [cms.Process]       : the 'cms.Process'
0194     - triggerProducer     : PATTriggerProducer module label;
0195                             optional, default: 'patTrigger'
0196     - path                : name of path to use;
0197                             optional, default: ''
0198     - hltProcess          : HLT process name;
0199                             optional, default: 'HLT'
0200     - outputModule        : output module label;
0201                             empty label indicates no output;
0202                             optional, default: 'out'
0203     Using None as any argument restores its default value.
0204     """
0205     _label             = 'switchOnTriggerStandAlone'
0206     _defaultParameters = dicttypes.SortedKeysDict()
0207 
0208     def __init__( self ):
0209         ConfigToolBase.__init__( self )
0210         self.addParameter( self._defaultParameters, 'triggerProducer', _defaultTriggerProducer, _defaultTriggerProducerComment )
0211         self.addParameter( self._defaultParameters, 'path'           , _defaultPath           , _defaultPathComment )
0212         self.addParameter( self._defaultParameters, 'hltProcess'     , _defaultHltProcess     , _defaultHltProcessComment )
0213         self.addParameter( self._defaultParameters, 'outputModule'   , _defaultOutputModule   , _defaultOutputModuleComment )
0214         self._parameters = copy.deepcopy( self._defaultParameters )
0215         self._comment = ""
0216 
0217     def getDefaultParameters( self ):
0218         return self._defaultParameters
0219 
0220     def __call__( self, process
0221                 , triggerProducer      = None
0222                 , path                 = None
0223                 , hltProcess           = None
0224                 , outputModule         = None
0225                 ):
0226         if triggerProducer is None:
0227             triggerProducer = self._defaultParameters[ 'triggerProducer' ].value
0228         if path is None:
0229             path = self._defaultParameters[ 'path' ].value
0230         if hltProcess is None:
0231             hltProcess = self._defaultParameters[ 'hltProcess' ].value
0232         if outputModule is None:
0233             outputModule = self._defaultParameters[ 'outputModule' ].value
0234         self.setParameter( 'triggerProducer', triggerProducer )
0235         self.setParameter( 'path'           , path )
0236         self.setParameter( 'hltProcess'     , hltProcess )
0237         self.setParameter( 'outputModule'   , outputModule )
0238         self.apply( process )
0239 
0240     def toolCode( self, process ):
0241 
0242         task = getPatAlgosToolsTask(process)
0243 
0244         triggerProducer = self._parameters[ 'triggerProducer' ].value
0245         path            = self._parameters[ 'path' ].value
0246         hltProcess      = self._parameters[ 'hltProcess' ].value
0247         outputModule    = self._parameters[ 'outputModule' ].value
0248 
0249         # Load default producer from existing config file, if needed
0250         if not hasattr( process, triggerProducer ):
0251             from PhysicsTools.PatAlgos.triggerLayer1.triggerProducer_cfi import patTrigger
0252             addToProcessAndTask(triggerProducer, patTrigger.clone( onlyStandAlone = True ), process, task)
0253         else:
0254             print('%s():'%( self._label ))
0255             print('    PATTriggerProducer module \'%s\' exists already in process'%( triggerProducer ))
0256             print('    ==> entry re-used')
0257             print(_longLine)
0258 
0259         # Maintain configuration
0260         trigProdMod             = getattr( process, triggerProducer )
0261         trigProdMod.processName = hltProcess
0262         if path != '':
0263             if not hasattr( process, path ):
0264                 prodPath = cms.Path( trigProdMod )
0265                 setattr( process, path, prodPath )
0266                 print('%s():'%( self._label ))
0267                 print('    Path \'%s\' does not exist in process'%( path ))
0268                 print('    ==> created')
0269                 print(_longLine)
0270             elif not triggerProducer in _modulesInPath( process, path ):
0271                 prodPath = getattr( process, path )
0272                 prodPath += trigProdMod
0273 
0274         # Add event content
0275         if outputModule != '':
0276             patTriggerEventContent = [ 'keep patTriggerObjectStandAlones_%s_*_%s'%( triggerProducer, process.name_() )
0277                                      ]
0278             if ( hasattr( trigProdMod, 'saveL1Refs' ) and trigProdMod.saveL1Refs.value() is True ):
0279                 patTriggerEventContent += patTriggerL1RefsEventContent
0280             getattr( process, outputModule ).outputCommands = _addEventContent( getattr( process, outputModule ).outputCommands, patTriggerEventContent )
0281 
0282 switchOnTriggerStandAlone = SwitchOnTriggerStandAlone()
0283 
0284 
0285 class SwitchOnTriggerMatching( ConfigToolBase ):
0286     """  Enables trigger matching in PAT
0287     SwitchOnTriggerMatching( [cms.Process], triggerMatchers = [default list], triggerProducer = 'patTrigger', triggerEventProducer = 'patTriggerEvent', path = '', hltProcess = 'HLT', outputModule = 'out', postfix = '' )
0288     - [cms.Process]       : the 'cms.Process'
0289     - triggerMatchers     : PAT trigger matcher module labels (list)
0290                             optional; default: defined in '_exampleTriggerMatchers'
0291                             (s. PhysicsTools/PatAlgos/python/triggerLayer1/triggerMatcherExamples_cfi.py)
0292     - triggerProducer     : PATTriggerProducer module label;
0293                             optional, default: 'patTrigger'
0294     - triggerEventProducer: PATTriggerEventProducer module label;
0295                             optional, default: 'patTriggerEvent'
0296     - path                : name of path to use;
0297                             optional, default: 'patDefaultSequence'
0298     - hltProcess          : HLT process name;
0299                             optional, default: 'HLT'
0300     - outputModule        : output module label;
0301                             empty label indicates no output;
0302                             optional, default: 'out'
0303     - postfix             : postfix to apply to PAT module labels;
0304                             optional, default: ''
0305     Using None as any argument restores its default value.
0306     """
0307     _label             = 'switchOnTriggerMatching'
0308     _defaultParameters = dicttypes.SortedKeysDict()
0309 
0310     def __init__( self ):
0311         ConfigToolBase.__init__( self )
0312         self.addParameter( self._defaultParameters, 'triggerMatchers'     , _exampleTriggerMatchers     , _defaultTriggerMatchersComment )
0313         self.addParameter( self._defaultParameters, 'exampleMatchers'     , False                       , '' )
0314         self.addParameter( self._defaultParameters, 'triggerProducer'     , _defaultTriggerProducer     , _defaultTriggerProducerComment )
0315         self.addParameter( self._defaultParameters, 'triggerEventProducer', _defaultTriggerEventProducer, _defaultTriggerEventProducerComment )
0316         self.addParameter( self._defaultParameters, 'path'                , _defaultPath                , _defaultPathComment )
0317         self.addParameter( self._defaultParameters, 'hltProcess'          , _defaultHltProcess          , _defaultHltProcessComment )
0318         self.addParameter( self._defaultParameters, 'outputModule'        , _defaultOutputModule        , _defaultOutputModuleComment )
0319         self.addParameter( self._defaultParameters, 'postfix'             , _defaultPostfix             , _defaultPostfixComment )
0320         self._parameters = copy.deepcopy( self._defaultParameters )
0321         self._comment = ""
0322 
0323     def getDefaultParameters( self ):
0324         return self._defaultParameters
0325 
0326     def __call__( self, process
0327                 , triggerMatchers      = None
0328                 , triggerProducer      = None
0329                 , triggerEventProducer = None
0330                 , path                 = None
0331                 , hltProcess           = None
0332                 , outputModule         = None
0333                 , postfix              = None
0334                 ):
0335         if triggerMatchers is None:
0336             triggerMatchers = self._defaultParameters[ 'triggerMatchers' ].value
0337             self.setParameter( 'exampleMatchers', True )
0338         if triggerProducer is None:
0339             triggerProducer = self._defaultParameters[ 'triggerProducer' ].value
0340         if triggerEventProducer is None:
0341             triggerEventProducer = self._defaultParameters[ 'triggerEventProducer' ].value
0342         if path is None:
0343             path = self._defaultParameters[ 'path' ].value
0344         if hltProcess is None:
0345             hltProcess = self._defaultParameters[ 'hltProcess' ].value
0346         if outputModule is None:
0347             outputModule = self._defaultParameters[ 'outputModule' ].value
0348         if postfix is None:
0349             postfix = self._defaultParameters[ 'postfix' ].value
0350         self.setParameter( 'triggerMatchers'     , triggerMatchers )
0351         self.setParameter( 'triggerProducer'     , triggerProducer )
0352         self.setParameter( 'triggerEventProducer', triggerEventProducer )
0353         self.setParameter( 'path'                , path )
0354         self.setParameter( 'hltProcess'          , hltProcess )
0355         self.setParameter( 'outputModule'        , outputModule )
0356         self.setParameter( 'postfix'             , postfix )
0357         self.apply( process )
0358 
0359     def toolCode( self, process ):
0360         triggerMatchers      = self._parameters[ 'triggerMatchers' ].value
0361         exampleMatchers      = self._parameters[ 'exampleMatchers' ].value
0362         triggerProducer      = self._parameters[ 'triggerProducer' ].value
0363         triggerEventProducer = self._parameters[ 'triggerEventProducer' ].value
0364         path                 = self._parameters[ 'path' ].value
0365         hltProcess           = self._parameters[ 'hltProcess' ].value
0366         outputModule         = self._parameters[ 'outputModule' ].value
0367         postfix              = self._parameters[ 'postfix' ].value
0368 
0369         # Load default producers from existing config file, if needed
0370         task = getPatAlgosToolsTask(process)
0371         if exampleMatchers:
0372             process.load( "PhysicsTools.PatAlgos.triggerLayer1.triggerMatcherExamples_cfi" )
0373             task.add(process.triggerMatcherExamplesTask)
0374         # Switch on PAT trigger information if needed
0375         if not hasattr( process, triggerEventProducer ):
0376             print('%s():'%( self._label ))
0377             print('    PAT trigger production switched on automatically using')
0378             print('    switchOnTrigger( process, \'%s\', \'%s\', \'%s\', \'%s\', \'%s\' )'%( hltProcess, triggerProducer, triggerEventProducer, path, outputModule ))
0379             print(_longLine)
0380             switchOnTrigger( process, triggerProducer, triggerEventProducer, path, hltProcess, outputModule )
0381 
0382         # Maintain configurations
0383         trigEvtProdMod = getattr( process, triggerEventProducer )
0384         triggerMatchersKnown = []
0385         for matcher in triggerMatchers:
0386             if not hasattr( process, matcher ):
0387                 print('%s():'%( self._label ))
0388                 print('    Matcher \'%s\' not known to process'%( matcher ))
0389                 print('    ==> skipped')
0390                 print(_longLine)
0391                 continue
0392             triggerMatchersKnown.append( matcher )
0393             trigMchMod         = getattr( process, matcher )
0394             trigMchMod.src     = cms.InputTag( trigMchMod.src.getModuleLabel() + postfix )
0395             trigMchMod.matched = triggerProducer
0396         matchers = getattr( trigEvtProdMod, 'patTriggerMatches' )
0397         if len( matchers ) > 0:
0398             print('%s():'%( self._label ))
0399             print('    PAT trigger matchers already attached to existing PATTriggerEventProducer \'%s\''%( triggerEventProducer ))
0400             print('    configuration parameters automatically changed')
0401             for matcher in matchers:
0402                 trigMchMod = getattr( process, matcher )
0403                 if trigMchMod.matched.value() is not triggerProducer:
0404                     trigMchMod.matched = triggerProducer
0405                     print('    PAT trigger matcher %s.matched --> %s'%( matcher, trigMchMod.matched ))
0406             print(_longLine)
0407         else:
0408             trigEvtProdMod.patTriggerMatches = cms.VInputTag()
0409         for matcher in triggerMatchersKnown:
0410             trigEvtProdMod.patTriggerMatches.append( cms.InputTag( matcher ) )
0411 
0412         # Add event content
0413         if outputModule != '':
0414             patTriggerEventContent = []
0415             for matcher in triggerMatchersKnown:
0416                 patTriggerEventContent += [ 'keep patTriggerObjectsedmAssociation_%s_%s_%s'%( triggerEventProducer, matcher, process.name_() )
0417                                           , 'keep *_%s_*_*'%( getattr( process, matcher ).src.value() )
0418                                           ]
0419             getattr( process, outputModule ).outputCommands = _addEventContent( getattr( process, outputModule ).outputCommands, patTriggerEventContent )
0420 
0421 switchOnTriggerMatching = SwitchOnTriggerMatching()
0422 
0423 
0424 class SwitchOnTriggerMatchingStandAlone( ConfigToolBase ):
0425     """  Enables trigger matching in PAT
0426     SwitchOnTriggerMatchingStandAlone( [cms.Process], triggerMatchers = [default list], triggerProducer = 'patTrigger', path = '', hltProcess = 'HLT', outputModule = 'out', postfix = '' )
0427     - [cms.Process]  : the 'cms.Process'
0428     - triggerMatchers: PAT trigger matcher module labels (list)
0429                        optional; default: defined in 'triggerMatchingDefaultSequence'
0430                        (s. PhysicsTools/PatAlgos/python/triggerLayer1/triggerMatcherExamples_cfi.py)
0431     - triggerProducer: PATTriggerProducer module label;
0432                        optional, default: 'patTrigger'
0433     - path           : name of path to use;
0434                        optional, default: ''
0435     - hltProcess     : HLT process name;
0436                        optional, default: 'HLT'
0437     - outputModule   : output module label;
0438                        empty label indicates no output;
0439                        optional, default: 'out'
0440     - postfix        : postfix to apply to PAT module labels;
0441                        optional, default: ''
0442     Using None as any argument restores its default value.
0443     """
0444     _label             = 'switchOnTriggerMatchingStandAlone'
0445     _defaultParameters = dicttypes.SortedKeysDict()
0446 
0447     def __init__( self ):
0448         ConfigToolBase.__init__( self )
0449         self.addParameter( self._defaultParameters, 'triggerMatchers', _exampleTriggerMatchers, _defaultTriggerMatchersComment )
0450         self.addParameter( self._defaultParameters, 'exampleMatchers', False                  , '' )
0451         self.addParameter( self._defaultParameters, 'triggerProducer', _defaultTriggerProducer, _defaultTriggerProducerComment )
0452         self.addParameter( self._defaultParameters, 'path'           , _defaultPath           , _defaultPathComment )
0453         self.addParameter( self._defaultParameters, 'hltProcess'     , _defaultHltProcess     , _defaultHltProcessComment )
0454         self.addParameter( self._defaultParameters, 'outputModule'   , _defaultOutputModule   , _defaultOutputModuleComment )
0455         self.addParameter( self._defaultParameters, 'postfix'        , _defaultPostfix        , _defaultPostfixComment )
0456         self._parameters = copy.deepcopy( self._defaultParameters )
0457         self._comment = ""
0458 
0459     def getDefaultParameters( self ):
0460         return self._defaultParameters
0461 
0462     def __call__( self, process
0463                 , triggerMatchers = None
0464                 , triggerProducer = None
0465                 , path            = None
0466                 , hltProcess      = None
0467                 , outputModule    = None
0468                 , postfix         = None
0469                 ):
0470         if triggerMatchers is None:
0471             triggerMatchers = self._defaultParameters[ 'triggerMatchers' ].value
0472             self.setParameter( 'exampleMatchers', True )
0473         if triggerProducer is None:
0474             triggerProducer = self._defaultParameters[ 'triggerProducer' ].value
0475         if path is None:
0476             path = self._defaultParameters[ 'path' ].value
0477         if hltProcess is None:
0478             hltProcess = self._defaultParameters[ 'hltProcess' ].value
0479         if outputModule is None:
0480             outputModule = self._defaultParameters[ 'outputModule' ].value
0481         if postfix is None:
0482             postfix = self._defaultParameters[ 'postfix' ].value
0483         self.setParameter( 'triggerMatchers', triggerMatchers )
0484         self.setParameter( 'triggerProducer', triggerProducer )
0485         self.setParameter( 'path'           , path )
0486         self.setParameter( 'hltProcess'     , hltProcess )
0487         self.setParameter( 'outputModule'   , outputModule )
0488         self.setParameter( 'postfix'        , postfix )
0489         self.apply( process )
0490 
0491     def toolCode( self, process ):
0492         triggerMatchers = self._parameters[ 'triggerMatchers' ].value
0493         exampleMatchers = self._parameters[ 'exampleMatchers' ].value
0494         triggerProducer = self._parameters[ 'triggerProducer' ].value
0495         path            = self._parameters[ 'path' ].value
0496         hltProcess      = self._parameters[ 'hltProcess' ].value
0497         outputModule    = self._parameters[ 'outputModule' ].value
0498         postfix         = self._parameters[ 'postfix' ].value
0499 
0500         # Load default producers from existing config file, if needed
0501         task = getPatAlgosToolsTask(process)
0502         if exampleMatchers:
0503             process.load( "PhysicsTools.PatAlgos.triggerLayer1.triggerMatcherExamples_cfi" )
0504             task.add(process.triggerMatcherExamplesTask)
0505 
0506         # Switch on PAT trigger information if needed
0507         if not hasattr( process, triggerProducer ):
0508             print('%s():'%( self._label ))
0509             print('    PAT trigger production switched on automatically using')
0510             print('    switchOnTriggerStandAlone( process, \'%s\', \'%s\', \'%s\', \'%s\' )'%( hltProcess, triggerProducer, path, outputModule ))
0511             print(_longLine)
0512             switchOnTriggerStandAlone( process, triggerProducer, path, hltProcess, outputModule )
0513 
0514         # Maintain configurations
0515         triggerMatchersKnown = []
0516         for matcher in triggerMatchers:
0517             if not hasattr( process, matcher ):
0518                 print('%s():'%( self._label ))
0519                 print('    Matcher \'%s\' not known to process'%( matcher ))
0520                 print('    ==> skipped')
0521                 print(_longLine)
0522                 continue
0523             triggerMatchersKnown.append( matcher )
0524             trigMchMod         = getattr( process, matcher )
0525             trigMchMod.src     = cms.InputTag( trigMchMod.src.getModuleLabel() + postfix )
0526             trigMchMod.matched = triggerProducer
0527 
0528         # Add event content
0529         if outputModule != '':
0530             patTriggerEventContent = []
0531             for matcher in triggerMatchersKnown:
0532                 patTriggerEventContent += [ 'keep patTriggerObjectStandAlonesedmAssociation_%s_*_%s'%( matcher, process.name_() )
0533                                           , 'keep *_%s_*_*'%( getattr( process, matcher ).src.value() )
0534                                           ]
0535             getattr( process, outputModule ).outputCommands = _addEventContent( getattr( process, outputModule ).outputCommands, patTriggerEventContent )
0536 
0537 switchOnTriggerMatchingStandAlone = SwitchOnTriggerMatchingStandAlone()
0538 
0539 
0540 class SwitchOnTriggerMatchEmbedding( ConfigToolBase ):
0541     """  Enables embedding of trigger matches into PAT objects
0542     SwitchOnTriggerMatchEmbedding( [cms.Process], triggerMatchers = [default list], triggerProducer = 'patTrigger', path = '', hltProcess = 'HLT', outputModule = 'out', postfix = '' )
0543     - [cms.Process]  : the 'cms.Process'
0544     - triggerMatchers: PAT trigger matcher module labels (list)
0545                        optional; default: defined in 'triggerMatchingDefaultSequence'
0546                        (s. PhysicsTools/PatAlgos/python/triggerLayer1/triggerMatcherExamples_cfi.py)
0547     - triggerProducer: PATTriggerProducer module label;
0548                        optional, default: 'patTrigger'
0549     - path           : name of path to use;
0550                        optional, default: ''
0551     - hltProcess     : HLT process name;
0552                        optional, default: 'HLT'
0553     - outputModule   : output module label;
0554                        empty label indicates no output;
0555                        optional, default: 'out'
0556     - postfix        : postfix to apply to PAT module labels;
0557                        optional, default: ''
0558     Using None as any argument restores its default value.
0559     """
0560     _label             = 'switchOnTriggerMatchEmbedding'
0561     _defaultParameters = dicttypes.SortedKeysDict()
0562 
0563     def __init__( self ):
0564         ConfigToolBase.__init__( self )
0565         self.addParameter( self._defaultParameters, 'triggerMatchers', _exampleTriggerMatchers, _defaultTriggerMatchersComment )
0566         self.addParameter( self._defaultParameters, 'exampleMatchers', False                  , '' )
0567         self.addParameter( self._defaultParameters, 'triggerProducer', _defaultTriggerProducer, _defaultTriggerProducerComment )
0568         self.addParameter( self._defaultParameters, 'path'           , _defaultPath           , _defaultPathComment )
0569         self.addParameter( self._defaultParameters, 'hltProcess'     , _defaultHltProcess     , _defaultHltProcessComment )
0570         self.addParameter( self._defaultParameters, 'outputModule'   , _defaultOutputModule   , _defaultOutputModuleComment )
0571         self.addParameter( self._defaultParameters, 'postfix'        , _defaultPostfix        , _defaultPostfixComment )
0572         self._parameters = copy.deepcopy( self._defaultParameters )
0573         self._comment = ""
0574 
0575     def getDefaultParameters( self ):
0576         return self._defaultParameters
0577 
0578     def __call__( self, process
0579                 , triggerMatchers = None
0580                 , triggerProducer = None
0581                 , path            = None
0582                 , hltProcess      = None
0583                 , outputModule    = None
0584                 , postfix         = None
0585                 ):
0586         if triggerMatchers is None:
0587             triggerMatchers = self._defaultParameters[ 'triggerMatchers' ].value
0588             self.setParameter( 'exampleMatchers', True )
0589         if triggerProducer is None:
0590             triggerProducer = self._defaultParameters[ 'triggerProducer' ].value
0591         if path is None:
0592             path = self._defaultParameters[ 'path' ].value
0593         if hltProcess is None:
0594             hltProcess = self._defaultParameters[ 'hltProcess' ].value
0595         if outputModule is None:
0596             outputModule = self._defaultParameters[ 'outputModule' ].value
0597         if postfix is None:
0598             postfix = self._defaultParameters[ 'postfix' ].value
0599         self.setParameter( 'triggerMatchers', triggerMatchers )
0600         self.setParameter( 'triggerProducer', triggerProducer )
0601         self.setParameter( 'path'           , path )
0602         self.setParameter( 'hltProcess'     , hltProcess )
0603         self.setParameter( 'outputModule'   , outputModule )
0604         self.setParameter( 'postfix'        , postfix )
0605         self.apply( process )
0606 
0607     def toolCode( self, process ):
0608         triggerMatchers = self._parameters[ 'triggerMatchers' ].value
0609         exampleMatchers = self._parameters[ 'exampleMatchers' ].value
0610         triggerProducer = self._parameters[ 'triggerProducer' ].value
0611         path            = self._parameters[ 'path' ].value
0612         hltProcess      = self._parameters[ 'hltProcess' ].value
0613         outputModule    = self._parameters[ 'outputModule' ].value
0614         postfix         = self._parameters[ 'postfix' ].value
0615 
0616         # Load default producers from existing config file, if needed
0617         task = getPatAlgosToolsTask(process)
0618         if exampleMatchers:
0619             process.load( "PhysicsTools.PatAlgos.triggerLayer1.triggerMatcherExamples_cfi" )
0620             task.add(process.triggerMatcherExamplesTask)
0621 
0622         # Build dictionary of allowed input producers
0623         dictPatProducers = { 'PATPhotonCleaner'  : 'PATTriggerMatchPhotonEmbedder'
0624                            , 'PATElectronCleaner': 'PATTriggerMatchElectronEmbedder'
0625                            , 'PATMuonCleaner'    : 'PATTriggerMatchMuonEmbedder'
0626                            , 'PATTauCleaner'     : 'PATTriggerMatchTauEmbedder'
0627                            , 'PATJetCleaner'     : 'PATTriggerMatchJetEmbedder'
0628                            , 'PATMETCleaner'     : 'PATTriggerMatchMETEmbedder'
0629 #                            , 'PATGenericParticleCleaner'     : ''
0630 #                            , 'PATPFParticleCleaner'     : ''
0631                            , 'PATPhotonSelector'  : 'PATTriggerMatchPhotonEmbedder'
0632                            , 'PATElectronSelector': 'PATTriggerMatchElectronEmbedder'
0633                            , 'PATMuonSelector'    : 'PATTriggerMatchMuonEmbedder'
0634                            , 'PATTauSelector'     : 'PATTriggerMatchTauEmbedder'
0635                            , 'PATJetSelector'     : 'PATTriggerMatchJetEmbedder'
0636                            , 'PATMETSelector'     : 'PATTriggerMatchMETEmbedder'
0637 #                            , 'PATGenericParticleSelector'     : ''
0638 #                            , 'PATPFParticleSelector'     : ''
0639 #                            , 'PATCompositeCandidateSelector'     : ''
0640                            , 'PATPhotonRefSelector'  : 'PATTriggerMatchPhotonEmbedder'
0641                            , 'PATElectronRefSelector': 'PATTriggerMatchElectronEmbedder'
0642                            , 'PATMuonRefSelector'    : 'PATTriggerMatchMuonEmbedder'
0643                            , 'PATTauRefSelector'     : 'PATTriggerMatchTauEmbedder'
0644                            , 'PATJetRefSelector'     : 'PATTriggerMatchJetEmbedder'
0645                            , 'PATMETRefSelector'     : 'PATTriggerMatchMETEmbedder'
0646 #                            , 'PATGenericParticleRefSelector'     : ''
0647 #                            , 'PATPFParticleRefSelector'     : ''
0648 #                            , 'PATCompositeCandidateRefSelector'     : ''
0649                            , 'PATPhotonProducer'  : 'PATTriggerMatchPhotonEmbedder'
0650                            , 'PATElectronProducer': 'PATTriggerMatchElectronEmbedder'
0651                            , 'PATMuonProducer'    : 'PATTriggerMatchMuonEmbedder'
0652                            , 'PATTauProducer'     : 'PATTriggerMatchTauEmbedder'
0653                            , 'PATJetProducer'     : 'PATTriggerMatchJetEmbedder'
0654                            , 'PATMETProducer'     : 'PATTriggerMatchMETEmbedder'
0655 #                            , 'PATGenericParticleProducer'     : ''
0656 #                            , 'PATPFParticleProducer'     : ''
0657 #                            , 'PATCompositeCandidateProducer'     : ''
0658                            , 'MuonSelectorVertex': 'PATTriggerMatchMuonEmbedder'
0659                            }
0660 
0661         # Switch on PAT trigger matching if needed
0662         dictConfig = {}
0663         if not hasattr( process, triggerProducer ):
0664             if exampleMatchers:
0665                 print('%s():'%( self._label ))
0666                 print('    PAT trigger matching switched on automatically using')
0667                 print('    switchOnTriggerMatchingStandAlone( process, \'%s\', None, \'%s\', \'%s\', \'%s\', \'%s\' )'%( hltProcess, triggerProducer, path, outputModule, postfix ))
0668                 print(_longLine)
0669                 switchOnTriggerMatchingStandAlone( process, None, triggerProducer, path, hltProcess, '', postfix ) # Do not store intermediate output collections.
0670             else:
0671                 print('%s():'%( self._label ))
0672                 print('    PAT trigger matching switched on automatically using')
0673                 print('    switchOnTriggerMatchingStandAlone( process, \'%s\', %s, \'%s\', \'%s\', \'%s\', \'%s\' )'%( hltProcess, triggerMatchers, triggerProducer, path, outputModule, postfix ))
0674                 print(_longLine)
0675                 switchOnTriggerMatchingStandAlone( process, triggerMatchers, triggerProducer, path, hltProcess, '', postfix ) # Do not store intermediate output collections.
0676         elif exampleMatchers:
0677             process.load( "PhysicsTools.PatAlgos.triggerLayer1.triggerMatcherExamples_cfi" )
0678             task.add(process.triggerMatcherExamplesTask)
0679 
0680         # Build dictionary of matchers
0681         for matcher in triggerMatchers:
0682             if not hasattr( process, matcher ):
0683                 print('%s():'%( self._label ))
0684                 print('    PAT trigger matcher \'%s\' not known to process'%( matcher ))
0685                 print('    ==> skipped')
0686                 print(_longLine)
0687                 continue
0688             trigMchMod = getattr( process, matcher )
0689             patObjProd = getattr( process, trigMchMod.src.value() + postfix )
0690             if trigMchMod.src.value() in dictConfig:
0691                 dictConfig[ patObjProd.type_() ] += [ matcher ]
0692             else:
0693                 dictConfig[ patObjProd.type_() ] = [ matcher ]
0694 
0695         # Maintain configurations
0696         patTriggerEventContent = []
0697         for patObjProdType in dictConfig.keys():
0698             if patObjProdType in dictPatProducers:
0699                 for matcher in dictConfig[ patObjProdType ]:
0700                     trigMchMod = getattr( process, matcher )
0701                     patObjProd = getattr( process, trigMchMod.src.value() + postfix )
0702                     # Configure embedder module
0703                     label = patObjProd.label_() + 'TriggerMatch' # hardcoded default
0704                     if hasattr( process, label ):
0705                         print('%s():'%( self._label ))
0706                         print('    PAT trigger match embedder \'%s\' exists already in process'%( label ))
0707                         print('    ==> entry re-used')
0708                         print(_longLine)
0709                         module = getattr( process, label )
0710                         if not module.type_() is dictPatProducers[ patObjProdType ]:
0711                             print('%s():'%( self._label ))
0712                             print('    Configuration conflict for PAT trigger match embedder \'%s\''%( label ))
0713                             print('    - exists as %s'%( module.type_() ))
0714                             print('    - requested as %s by \'%s\''%( dictPatProducers[ patObjProdType ], matcher ))
0715                             print('    ==> skipped')
0716                             print(_longLine)
0717                             continue
0718                         if not module.src.value() is trigMchMod.src.value() + postfix:
0719                             print('%s():'%( self._label ))
0720                             print('    Configuration conflict for PAT trigger match embedder \'%s\''%( label ))
0721                             print('    - exists for input %s'%( module.src.value() ))
0722                             print('    - requested for input %s by \'%s\''%( trigMchMod.src.value() + postfix, matcher ))
0723                             print('    ==> skipped')
0724                             print(_longLine)
0725                             continue
0726                         module.matches.append( cms.InputTag( matcher ) )
0727                     else:
0728                         module         = cms.EDProducer( dictPatProducers[ patObjProdType ] )
0729                         module.src     = cms.InputTag( patObjProd.label_() )
0730                         module.matches = cms.VInputTag( matcher )
0731                         addToProcessAndTask(label, module, process, task)
0732                     # Add event content
0733                     patTriggerEventContent += [ 'drop *_%s_*_*'%( patObjProd.label_() )
0734                                               , 'keep *_%s_*_%s'%( label, process.name_() )
0735                                               ]
0736             else:
0737                 print('%s():'%( self._label ))
0738                 print('    Invalid input source for trigger match embedding')
0739                 print('    ==> %s with matchers \'%s\' is skipped'%( patObjProdType, dictConfig[ patObjProdType ] ))
0740                 print(_longLine)
0741         if outputModule != '':
0742             getattr( process, outputModule ).outputCommands = _addEventContent( getattr( process, outputModule ).outputCommands, patTriggerEventContent )
0743 
0744 switchOnTriggerMatchEmbedding = SwitchOnTriggerMatchEmbedding()