Esempi in Python per HGCalTriggerChains.register_backend2

Esempio n. 1

File: runNtuple_v10.6_geomv9.py Progetto: jheikkil/submission

# ---------------------------------------------------------------------------
# here we define our custom chain for HGC TPs
from L1Trigger.L1THGCalUtilities.hgcalTriggerChains import HGCalTriggerChains
import L1Trigger.L1THGCalUtilities.vfe as vfe
import L1Trigger.L1THGCalUtilities.concentrator as concentrator
import L1Trigger.L1THGCalUtilities.clustering2d as clustering2d
import L1Trigger.L1THGCalUtilities.clustering3d as clustering3d

chain = HGCalTriggerChains()
chain.register_vfe("VFEfp7", vfe.create_compression)
chain.register_concentrator("tcTh", concentrator.create_threshold)
# chain.register_concentrator("sTC", concentrator.create_supertriggercell)
# chain.register_backend1("dRNNC2d", clustering2d.create_constrainedtopological)
chain.register_backend1("dummyC2d", clustering2d.create_dummy)
chain.register_backend2("histoMaxC3dVR",
                        clustering3d.create_histoMax_variableDr)
# chain.register_backend2("histoMaxC3dVRPhiBins", lambda p, i: clustering3d.create_histoMax_variableDr(p, i, nBins_Phi=108))
# chain.register_backend2("dRC3d", clustering3d.create_distance)
# chain.register_chain('VFEfp7', 'tcTh', 'dummyC2d', 'histoMaxC3d')
chain.register_chain('VFEfp7', 'tcTh', 'dummyC2d', 'histoMaxC3dVR')
# chain.register_chain('VFEfp7', 'tcTh', 'dummyC2d', 'histoMaxC3dVRPhiBins')
# chain.register_chain('VFEfp7', 'sTC', 'dummyC2d', 'histoMaxC3dVR')
# chain.register_chain('VFEfp7', 'tcTh', 'dRNNC2d', 'dRC3d')
# chain.register_chain('Floatingpoint7', 'Threshold', 'Dummy', 'Histothreshold')
# chain.register_chain('Floatingpoint7', 'Bestchoice', 'Dummy', 'Histothreshold')
process = chain.create_sequences(process)

# process.load("L1Trigger.L1THGCalUtilities.caloTruthCells_cff")
# process.caloTruthCellsProducer.triggerCells = cms.InputTag('VFEfp7:HGCalVFEProcessorSums')
# process.caloTruthCellsProducer.makeCellsCollection = True
# process.caloTruth_step = cms.Path(process.caloTruthCells)

Esempio n. 2

import L1Trigger.L1THGCalUtilities.customNtuples as ntuple

chains = HGCalTriggerChains()
# Register algorithms
## VFE
chains.register_vfe("Floatingpoint8",
                    lambda p: vfe.create_compression(p, 4, 4, True))
## ECON
chains.register_concentrator("Supertriggercell",
                             concentrator.create_supertriggercell)
chains.register_concentrator("Threshold", concentrator.create_threshold)
## BE1
chains.register_backend1("Ref2d", clustering2d.create_constrainedtopological)
chains.register_backend1("Dummy", clustering2d.create_dummy)
## BE2
chains.register_backend2("Ref3d", clustering3d.create_distance)
chains.register_backend2("Histomax", clustering3d.create_histoMax)
chains.register_backend2(
    "Histomaxvardrth0", lambda p, i: clustering3d.create_histoMax_variableDr(
        p, i, seed_threshold=0.))
chains.register_backend2(
    "Histomaxvardrth10", lambda p, i: clustering3d.create_histoMax_variableDr(
        p, i, seed_threshold=10.))
chains.register_backend2(
    "Histomaxvardrth20", lambda p, i: clustering3d.create_histoMax_variableDr(
        p, i, seed_threshold=20.))
# Register ntuples
# Store gen info only in the reference ntuple
ntuple_list_ref = ['event', 'gen', 'multiclusters']
ntuple_list = ['event', 'multiclusters']
chains.register_ntuple(

Esempio n. 3

File: runNtuple_v10.5.py Progetto: mcepeda/submission

from L1Trigger.L1THGCalUtilities.hgcalTriggerChains import HGCalTriggerChains
import L1Trigger.L1THGCalUtilities.vfe as vfe
import L1Trigger.L1THGCalUtilities.concentrator as concentrator
import L1Trigger.L1THGCalUtilities.clustering2d as clustering2d
import L1Trigger.L1THGCalUtilities.clustering3d as clustering3d

chain = HGCalTriggerChains()
chain.register_vfe("VFEfp7", vfe.create_compression)
chain.register_concentrator("tcTh", concentrator.create_threshold)
chain.register_concentrator("sTC", concentrator.create_supertriggercell)

chain.register_backend1("dRNNC2d", clustering2d.create_constrainedtopological)
chain.register_backend1("dummyC2d", clustering2d.create_dummy)

chain.register_backend2("histoMaxC3dVR",
                        clustering3d.create_histoMax_variableDr)
chain.register_backend2(
    "histoMaxC3dVRPhiBins",
    lambda p, i: clustering3d.create_histoMax_variableDr(p, i, nBins_Phi=108))

chain.register_backend2("dRC3d", clustering3d.create_distance)

# chain.register_chain('VFEfp7', 'tcTh', 'dummyC2d', 'histoMaxC3d')
chain.register_chain('VFEfp7', 'tcTh', 'dummyC2d', 'histoMaxC3dVR')
chain.register_chain('VFEfp7', 'tcTh', 'dummyC2d', 'histoMaxC3dVRPhiBins')
chain.register_chain('VFEfp7', 'sTC', 'dummyC2d', 'histoMaxC3dVR')
chain.register_chain('VFEfp7', 'tcTh', 'dRNNC2d', 'dRC3d')

# chain.register_chain('Floatingpoint7', 'Threshold', 'Dummy', 'Histothreshold')
# chain.register_chain('Floatingpoint7', 'Bestchoice', 'Dummy', 'Histothreshold')
process = chain.create_sequences(process)

Esempio n. 4

chains.register_concentrator(
    "Supertriggercell4444fixed",
    lambda p, i: concentrator.create_supertriggercell(
        p, i, stcSize=cms.vuint32(4, 8, 8, 8), fixedDataSizePerHGCROC=True))
chains.register_concentrator(
    "Equalshare", lambda p, i: concentrator.create_supertriggercell(
        p,
        i,
        stcSize=cms.vuint32(4, 8, 8, 8),
        fixedDataSizePerHGCROC=True,
        type_energy_division='equalShare'))
chains.register_concentrator("Onebit", concentrator.create_onebitfraction)
## BE1
chains.register_backend1("Dummy", clustering2d.create_dummy)
## BE2
chains.register_backend2("Histomax", clustering3d.create_histoMax_variableDr)
chains.register_backend2(
    "Histomaxshape15", lambda p, i: clustering3d.create_histoMax_variableDr(
        p, i, shape_threshold=1.5))
### Varies seed threshold
chains.register_backend2(
    "Histomaxth0", lambda p, i: clustering3d.create_histoMax_variableDr(
        p, i, seed_threshold=0.))
chains.register_backend2(
    "Histomaxth0shape15", lambda p, i: clustering3d.create_histoMax_variableDr(
        p, i, seed_threshold=0., shape_threshold=1.5))
chains.register_backend2(
    "Histomaxth20", lambda p, i: clustering3d.create_histoMax_variableDr(
        p, i, seed_threshold=20.))
chains.register_backend2(
    "Histomaxth20shape15", lambda p, i: clustering3d.

Esempio n. 5

File: testHGCalL1T_multialgo_cfg.py Progetto: Moanwar/cmssw

import L1Trigger.L1THGCalUtilities.clustering3d as clustering3d
import L1Trigger.L1THGCalUtilities.customNtuples as ntuple


chains = HGCalTriggerChains()
# Register algorithms
## VFE
chains.register_vfe("Floatingpoint8", lambda p : vfe.create_compression(p, 4, 4, True))
## ECON
chains.register_concentrator("Supertriggercell", concentrator.create_supertriggercell)
chains.register_concentrator("Threshold", concentrator.create_threshold)
## BE1
chains.register_backend1("Ref2d", clustering2d.create_constrainedtopological)
chains.register_backend1("Dummy", clustering2d.create_dummy)
## BE2
chains.register_backend2("Ref3d", clustering3d.create_distance)
chains.register_backend2("Histomax", clustering3d.create_histoMax)
chains.register_backend2("Histomaxvardrth0", lambda p,i : clustering3d.create_histoMax_variableDr(p,i,seed_threshold=0.))
chains.register_backend2("Histomaxvardrth10", lambda p,i : clustering3d.create_histoMax_variableDr(p,i,seed_threshold=10.))
chains.register_backend2("Histomaxvardrth20", lambda p,i : clustering3d.create_histoMax_variableDr(p,i,seed_threshold=20.))
# Register ntuples
# Store gen info only in the reference ntuple
ntuple_list_ref = ['event', 'gen', 'multiclusters']
ntuple_list = ['event', 'multiclusters']
chains.register_ntuple("Genclustersntuple", lambda p,i : ntuple.create_ntuple(p,i, ntuple_list_ref))
chains.register_ntuple("Clustersntuple", lambda p,i : ntuple.create_ntuple(p,i, ntuple_list))

# Register trigger chains
## Reference chain
chains.register_chain('Floatingpoint8', "Threshold", 'Ref2d', 'Ref3d', 'Genclustersntuple')
concentrator_algos = ['Supertriggercell', 'Threshold']

Esempio n. 6

File: testHGCalL1T_multialgo_with_truth_cfg.py Progetto: p2l1pfp/cmssw

import L1Trigger.L1THGCalUtilities.truth_prod as truth_prod
import L1Trigger.L1THGCalUtilities.clustering2d as clustering2d
import L1Trigger.L1THGCalUtilities.clustering3d as clustering3d
import L1Trigger.L1THGCalUtilities.selectors as selectors
import L1Trigger.L1THGCalUtilities.customNtuples as ntuple

chains = HGCalTriggerChains()
# Register algorithms
## VFE
chains.register_vfe("Floatingpoint", vfe.create_vfe)
## TRUTH PRODUCER
chains.register_truth_prod("TruthProd", truth_prod.create_truth_prod)
## BE1
chains.register_backend1("TruthDummy", clustering2d.create_truth_dummy)
## BE2
chains.register_backend2("Histomax", clustering3d.create_histoMax)
# Register selector
chains.register_selector("Genmatch", selectors.create_genmatch)
# Register ntuples
ntuple_list = ['event', 'gen', 'multiclusters']
chains.register_ntuple("Genclustersntuple",
                       lambda p, i: ntuple.create_ntuple(p, i, ntuple_list))

# Register trigger chains
backend_algos = ['Histomax']

chains.register_truth_chain('Floatingpoint', 'TruthProd', '', '', '',
                            'Genclustersntuple')
for be in backend_algos:
    chains.register_truth_chain('Floatingpoint', 'TruthProd', 'TruthDummy', be,
                                'Genmatch', 'Genclustersntuple')

Esempio n. 7

File: produce_ntuple_multialgos_reduced_genmatch_v9_cfg.py Progetto: PFCal-dev/HGCTPGNtupleProduction

    "Supertriggercell4444Fixed",
    lambda p, i: concentrator.create_supertriggercell(
        p, i, stcSize=cms.vuint32(4, 8, 8, 8), fixedDataSizePerHGCROC=True))
chains.register_concentrator(
    "Equalshare", lambda p, i: concentrator.create_supertriggercell(
        p,
        i,
        stcSize=cms.vuint32(4, 8, 8, 8),
        fixedDataSizePerHGCROC=True,
        type_energy_division='equalShare'))
chains.register_concentrator("Onebit", concentrator.create_onebitfraction)
## BE1
chains.register_backend1("Ref2d", clustering2d.create_constrainedtopological)
chains.register_backend1("Dummy", clustering2d.create_dummy)
## BE2
chains.register_backend2("Ref3d", clustering3d.create_distance)
### Varies seed threshold
chains.register_backend2(
    "Histomaxth0", lambda p, i: clustering3d.create_histoMax_variableDr(
        p, i, seed_threshold=0.))
chains.register_backend2(
    "Histomaxth10", lambda p, i: clustering3d.create_histoMax_variableDr(
        p, i, seed_threshold=10.))
chains.register_backend2(
    "Histomaxth20", lambda p, i: clustering3d.create_histoMax_variableDr(
        p, i, seed_threshold=20.))
### Varies clustering distance
from L1Trigger.L1THGCal.customClustering import dr_layerbylayer
dr_layerbylayer_25 = [dr * 1.25 for dr in dr_layerbylayer]
dr_layerbylayer_50 = [dr * 1.5 for dr in dr_layerbylayer]
dr_layerbylayer_100 = [dr * 2. for dr in dr_layerbylayer]

Esempio n. 8

File: produce_ntuple_th_bc_xyseed_reduced_genmatch_v9_cfg.py Progetto: PFCal-dev/HGCTPGNtupleProduction

## ECON
chains.register_concentrator("Threshold",
        concentrator.create_threshold)
chains.register_concentrator('Threshold0',
        lambda p,i :concentrator.create_threshold(p,i,
            threshold_silicon=0.,threshold_scintillator=0.))
chains.register_concentrator('Threshold1',
        lambda p,i :concentrator.create_threshold(p,i,
            threshold_silicon=1.,threshold_scintillator=1.))
chains.register_concentrator("Bestchoice",
        concentrator.create_bestchoice)
## BE1
chains.register_backend1("Dummy",
        clustering2d.create_dummy)
## BE2
chains.register_backend2("Histomax",
        clustering3d.create_histoMaxXY_variableDr)
### Varies clustering distance
from L1Trigger.L1THGCal.customClustering import dr_layerbylayer
dr_layerbylayer_50 = [dr*0.5 for dr in dr_layerbylayer]
dr_layerbylayer_200 = [dr*2. for dr in dr_layerbylayer]
chains.register_backend2("Histomaxdr50",
        lambda p,i : clustering3d.create_histoMaxXY_variableDr(p,i,
    distances=dr_layerbylayer_50))
chains.register_backend2("Histomaxdr200",
        lambda p,i : clustering3d.create_histoMaxXY_variableDr(p,i,
    distances=dr_layerbylayer_200))
# Register selector
chains.register_selector("Genmatch", selectors.create_genmatch)
# Register ntuples
# Store gen info only in the reference ntuple
ntuple_list = ['event', 'gen', 'multiclusters']

Esempio n. 9

File: testHGCalL1T_multialgo_V11_cfg.py Progetto: wweiphy/cmssw

import L1Trigger.L1THGCalUtilities.customNtuples as ntuple

chains = HGCalTriggerChains()
# Register algorithms
## VFE
chains.register_vfe("Floatingpoint", vfe.CreateVfe())
## ECON
chains.register_concentrator("Supertriggercell",
                             concentrator.CreateSuperTriggerCell())
chains.register_concentrator("Threshold", concentrator.CreateThreshold())
chains.register_concentrator("Bestchoice", concentrator.CreateBestChoice())
chains.register_concentrator("AutoEncoder", concentrator.CreateAutoencoder())
## BE1
chains.register_backend1("Dummy", clustering2d.CreateDummy())
## BE2
chains.register_backend2("Histomax", clustering3d.CreateHistoMax())
# Register selector
chains.register_selector("Genmatch", selectors.CreateGenMatch())

# Register ntuples
ntuple_list = ['event', 'gen', 'multiclusters']
chains.register_ntuple("Genclustersntuple", ntuple.CreateNtuple(ntuple_list))

# Register trigger chains
concentrator_algos = [
    'Supertriggercell', 'Threshold', 'Bestchoice', 'AutoEncoder'
]
backend_algos = ['Histomax']
## Make cross product fo ECON and BE algos
import itertools
for cc, be in itertools.product(concentrator_algos, backend_algos):

Esempio n. 10

chains.register_concentrator("Supertriggercell",
        concentrator.create_supertriggercell)
chains.register_concentrator("Supertriggercell4444fixed",
        lambda p,i : concentrator.create_supertriggercell(p,i,
            stcSize=cms.vuint32(4,8,8,8),fixedDataSizePerHGCROC=True ))
chains.register_concentrator("Equalshare",
        lambda p,i : concentrator.create_supertriggercell(p,i,
            stcSize=cms.vuint32(4,8,8,8),fixedDataSizePerHGCROC=True,type_energy_division='equalShare'))
chains.register_concentrator("Onebit",
        concentrator.create_onebitfraction)
## BE1
chains.register_backend1("Dummy",
        clustering2d.create_dummy)
## BE2
chains.register_backend2("Histomaxbin4",
        lambda p,i : clustering3d.create_histoMaxXY_variableDr(p,i,
        nBins_X1=96,
        nBins_X2=96))
chains.register_backend2("Histomaxbin4shape15",
        lambda p,i : clustering3d.create_histoMaxXY_variableDr(p,i,
        nBins_X1=96,
        nBins_X2=96,
        shape_threshold=1.5))
### Varies clustering distance
from L1Trigger.L1THGCal.customClustering import dr_layerbylayer
dr_layerbylayer_50 = [dr*0.5 for dr in dr_layerbylayer]
dr_layerbylayer_200 = [dr*2. for dr in dr_layerbylayer]
chains.register_backend2("Histomaxbin4dr50",
        lambda p,i : clustering3d.create_histoMaxXY_variableDr(p,i,
        nBins_X1=96,
        nBins_X2=96,
    distances=dr_layerbylayer_50))

Esempio n. 11

File: hgcal_l1t_ntupliser_v9_cfg.py Progetto: jonathon-langford/hgcal_l1t_egid

import L1Trigger.L1THGCalUtilities.customNtuples as ntuple

chains = HGCalTriggerChains()
# Register algorithms
## VFE
chains.register_vfe("Floatingpoint8",
                    lambda p: vfe.create_compression(p, 4, 4, True))
## ECON
chains.register_concentrator("Threshold", concentrator.create_threshold)
chains.register_concentrator("Supertriggercell",
                             concentrator.create_supertriggercell)
## BE1
chains.register_backend1("Dummy", clustering2d.create_dummy)
## BE2
chains.register_backend2(
    "Histomaxvardr",
    lambda p, i: clustering3d.create_histoMax_variableDr(p, i))
# Register ntuples
# Store gen info only in the reference ntuple
ntuple_list_ref = ['event', 'gen', 'multiclusters']
ntuple_list = ['event', 'multiclusters']
chains.register_ntuple(
    "Genclustersntuple",
    lambda p, i: ntuple.create_ntuple(p, i, ntuple_list_ref))
chains.register_ntuple("Clustersntuple",
                       lambda p, i: ntuple.create_ntuple(p, i, ntuple_list))

# Register trigger chains
concentrator_algos = ['Threshold', 'Supertriggercell']
backend_algos = ['Histomaxvardr']
## Make cross product fo ECON and BE algos