Complete: 3

Detailed Review status

Introduction

Local reco sequence description

Summary of the standard algorythm (for the impatient user)

ALERT! All algorithm not mentioned here is officially not supported and its usage is discouraged (even if maintained in Github)

Local Reconstruction (for CMS calorimeters)

The local reconstruction of the CMS calorimetry systems ECAL + HCAL + Castor is maintained under the CMSSW System RecoLocalCalo.

The sequences are defined in RecoLocalCalo/Configuration and includes

  • a collisions sequence (and corresponding event content) for a detector working in the nominal conditions for LHC collisions
More  Less 
    1import FWCore.ParameterSet.Config as cms
    2
    3#
    4# Ecal part
    5#
    6from RecoLocalCalo.Configuration.ecalLocalRecoSequence_cff import *
    7from RecoLocalCalo.EcalRecAlgos.EcalSeverityLevelESProducer_cfi import *
    8
    9#defines a sequence ecalLocalRecoSequence
   10#
   11# Hcal part
   12#
   13# calo geometry
   14#
   15# changed by tommaso. now the calibrations are read from Configuration/StaqndardSequences/data/*Conditions.cff
   16#
   17#HCAL reconstruction
   18from RecoLocalCalo.Configuration.hcalLocalReco_cff import *
   19from RecoLocalCalo.Configuration.hcalGlobalReco_cff import *
   20#
   21# sequence CaloLocalReco and CaloGlobalReco
   22#
   23calolocalrecoTask = cms.Task(ecalLocalRecoTask,hcalLocalRecoTask)
   24calolocalreco = cms.Sequence(calolocalrecoTask)
   25
   26from RecoLocalCalo.HcalRecProducers.HcalHitSelection_cfi import *
   27reducedHcalRecHitsTask = cms.Task( reducedHcalRecHits )
   28reducedHcalRecHitsSequence = cms.Sequence(reducedHcalRecHitsTask)
   29#
   30# R.Ofierzynski (29.Oct.2009): add NZS sequence
   31#
   32from RecoLocalCalo.Configuration.hcalLocalRecoNZS_cff import *
   33calolocalrecoTaskNZS = cms.Task(ecalLocalRecoTask,hcalLocalRecoTask,hcalLocalRecoTaskNZS)
   34calolocalrecoNZS = cms.Sequence(calolocalrecoTaskNZS)
   35
   36from RecoLocalCalo.Configuration.hgcalLocalReco_cff import *
   37_phase2_calolocalrecoTask = calolocalrecoTask.copy()
   38_phase2_calolocalrecoTask.add(hgcalLocalRecoTask)
   39
   40from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
   41phase2_hgcal.toReplaceWith( calolocalrecoTask , _phase2_calolocalrecoTask )
  • a cosmics sequence (and corresponding event content) for all the data taking that is not reconstructed with a detector working under the conditions for the LHC collisions (e.g. different gain, particles not coming from the IP)
More  Less 
    1import FWCore.ParameterSet.Config as cms
    2
    3#
    4# Ecal part
    5#
    6from RecoLocalCalo.Configuration.ecalLocalRecoSequenceCosmics_cff import *
    7from RecoLocalCalo.EcalRecAlgos.EcalSeverityLevelESProducer_cfi import *
    8
    9#defines a sequence ecalLocalRecoSequence
   10
   11#
   12# Hcal part
   13#
   14#HCAL reconstruction
   15import RecoLocalCalo.Configuration.hcalLocalReco_cff as _hcalLocalReco_cff
   16from RecoLocalCalo.HcalRecAlgos.hcalRecAlgoESProd_cfi import *
   17from RecoLocalCalo.HcalRecAlgos.hcalChannelPropertiesESProd_cfi import *
   18#
   19# sequence CaloLocalReco
   20#
   21
   22def hbheCosmic(module):
   23    return module.clone(
   24        tsFromDB = False,
   25        recoParamsFromDB = False,
   26        algorithm = dict(
   27            useMahi = False,
   28            useM2 = False,
   29            useM3 = False,
   30            firstSampleShift = -1000,
   31            samplesToAdd = 10,
   32            correctForPhaseContainment = False,
   33        ),
   34        sipmQTSShift = -100,
   35        sipmQNTStoSum = 200,
   36    )
   37
   38hbhereco = hbheCosmic(_hcalLocalReco_cff.hbheprereco)
   39hfreco = _hcalLocalReco_cff._default_hfreco.clone(
   40    firstSample = 0,
   41    samplesToAdd = 10, ### min(10,size) in the algo
   42    correctForTimeslew = False,
   43    correctForPhaseContainment = False,
   44    tsFromDB = False,
   45    recoParamsFromDB = False,
   46    digiTimeFromDB = False,
   47)
   48horeco = _hcalLocalReco_cff.horeco.clone(
   49    firstSample = 0,
   50    samplesToAdd = 10,
   51    correctForTimeslew = False,
   52    correctForPhaseContainment = False,
   53    tsFromDB = False,
   54    recoParamsFromDB = False,
   55)
   56zdcreco = _hcalLocalReco_cff.zdcreco.clone(
   57#    firstSample = 1,
   58#    samplesToAdd = 8,
   59    correctForTimeslew = True,
   60    correctForPhaseContainment = True,
   61    correctionPhaseNS = 10.,
   62)
   63
   64# 2017 customs
   65from Configuration.Eras.Modifier_run2_HF_2017_cff import run2_HF_2017
   66
   67_phase1_hfreco = _hcalLocalReco_cff._phase1_hfreco.clone(
   68    algorithm = dict(
   69        Class = "HFSimpleTimeCheck",
   70        rejectAllFailures = False,
   71    )
   72)
   73
   74
   75run2_HF_2017.toReplaceWith(hfreco, _phase1_hfreco )
   76
   77hfprereco = _hcalLocalReco_cff.hfprereco.clone(
   78    sumAllTimeSlices = True
   79)
   80
   81from RecoLocalCalo.HcalRecProducers.hbheplan1_cfi import hbheplan1
   82
   83# redefine hcal sequence
   84hcalLocalRecoTask = cms.Task(hbhereco,hfreco,horeco,zdcreco)
   85hcalLocalRecoSequence = cms.Sequence(hcalLocalRecoTask)
   86
   87_phase1_hcalLocalRecoTask = hcalLocalRecoTask.copy()
   88_phase1_hcalLocalRecoTask.add(hfprereco)
   89run2_HF_2017.toReplaceWith(hcalLocalRecoTask, _phase1_hcalLocalRecoTask)
   90
   91# shuffle modules so "hbheplan1" produces final collection of hits named "hbhereco"
   92_plan1_hcalLocalRecoTask = _phase1_hcalLocalRecoTask.copy()
   93hbheprereco = hbhereco.clone()
   94_plan1_hcalLocalRecoTask.add(hbheprereco)
   95from Configuration.Eras.Modifier_run2_HEPlan1_2017_cff import run2_HEPlan1_2017
   96run2_HEPlan1_2017.toReplaceWith(hbhereco, hbheplan1)
   97run2_HEPlan1_2017.toReplaceWith(hcalLocalRecoTask, _plan1_hcalLocalRecoTask)
   98
   99hbhecollapse = hbheplan1.clone()
  100_collapse_hcalLocalRecoTask = _phase1_hcalLocalRecoTask.copy()
  101_collapse_hcalLocalRecoTask.add(hbheprereco)
  102from Configuration.ProcessModifiers.run2_HECollapse_2018_cff import run2_HECollapse_2018
  103run2_HECollapse_2018.toReplaceWith(hbhereco, hbhecollapse)
  104run2_HECollapse_2018.toReplaceWith(hcalLocalRecoTask, _collapse_hcalLocalRecoTask)
  105calolocalrecoTaskCosmics = cms.Task(ecalLocalRecoTaskCosmics,hcalLocalRecoTask)
  106calolocalrecoCosmics = cms.Sequence(calolocalrecoTaskCosmics)
  107#
  108# R.Ofierzynski (29.Oct.2009): add NZS sequence
  109#
  110from RecoLocalCalo.Configuration.hcalLocalRecoNZS_cff import *
  111calolocalrecoTaskCosmicsNZS = cms.Task(ecalLocalRecoTaskCosmics,hcalLocalRecoTask,hcalLocalRecoTaskNZS) 
  112calolocalrecoCosmicsNZS = cms.Sequence(calolocalrecoTaskCosmicsNZS) 

Collision sequence

  • local reco:
    • ecalGlobalUncalibRecHit : amplitude with weights, timing with ratio method, amplitude with ratio method (aimed at out-of-time events), recovery of saturation with leading edge sample
    • ecalDetIdToBeRecovered : collect channels with errors merging unpacker information (event based) and DB (run based) and define channels to be recovered if they fall in interesting regions according to SRP
    • ecalRecHit : for each uncalibRecHit produce a recHit, if channels is dead and in interesting region make sure it will be in the recHit collection with 0 energy, if recovery procedures are on then recover problematic channels (procedures are OFF by default), exclude from reconstruction channels with DB status equal to [ 10, 11, 12, 13, 14, 78, 142 ]
    • ecalPreshowerRecHit : from ES digis produce ES recHits reconstructing the amplitude with a fit method
  • clustering
    • hybridClusteringSequence : super clusters with the hybrid algorithm, relative super cluster corrections applied
    • multi5x5ClusteringSequence : basic clusters with multi5x5, super clusters from the basic clusters, preshower information added
    • multi5x5PreshowerClusteringSequence : super cluster corrections for multi5x super clusters with preshower information, preshower cluster shapes

Cosmics sequence

  • local reco:
    • ecalFixedAlphaBetaFitUncalibRecHit : amplitude reconstruction with fit method (alpha and beta parameters are fixed)
    • ecalWeightUncalibRecHit : amplitude reconstruction with weights method
    • ecalRecHit : for each uncalibRecHit from ecalFixedAlphaBetaFitUncalibRecHit produce a recHit, if channels is dead and in interesting region make sure it will be in the recHit collection with 0 energy, if recovery procedures are on then recover problematic channels (procedures are OFF by default), exclude from reconstruction channels with DB status equal to [ 1, 2, 3, 4, 8, 9, 10, 11, 12, 13, 14, 78, 142 ]
    • ecalPreshowerRecHit : from ES digis produce ES recHits reconstructing the amplitude with a fit method
  • clustering:
    • hybridClusteringSequence : super clusters with the hybrid algorithm, relative super cluster corrections applied
    • cosmicClusteringSequence : cosmic basic clusters algorithm (specially conceived for m.i.p. particles), cosmic super clusters (like multi5x5SuperClusterProducer with as input the cosmicBasicClusters)

For the detail of the configuration files, you can find below the corresponding one.

ALERT! Special for LHC startup: express stream and prompt reconstruction

For the first LHC collisions it may happen that we have special detector conditions (e.g. anomalous timing due to LHC synchronization). To reconstruct this first special runs, two sequences have been set up. Below the link to the HEAD of the complete python configuration files.

  • express stream reconstruction
More  Less  Failed to include URL http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/CMSSW/Configuration/GlobalRuns/python/promptCollisionReco_FirstCollisions_RAW2DIGI_L1Reco_RECO_DQM_ALCA.py?view=markup Can't connect to cmssw.cvs.cern.ch:80 (Bad hostname)
  • prompt reconstruction
More  Less  Failed to include URL http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/CMSSW/Configuration/GlobalRuns/python/promptCollisionReco_FirstCollisions_RAW2DIGI_L1Reco_RECO_DQM_ALCA.py?view=markup Can't connect to cmssw.cvs.cern.ch:80 (Bad hostname)

ECAL local reconstruction

The ECAL local reco sequences are included from the configuration files in RecoLocalCalo/Configuration:

  • collisions (HEAD version):
More  Less  Failed to include URL http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/CMSSW/RecoLocalCalo/Configuration/python/ecalLocalRecoSequence_cff.py?view=markup Can't connect to cmssw.cvs.cern.ch:80 (Bad hostname)
  • cosmics (HEAD version):
More  Less  Failed to include URL http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/CMSSW/RecoLocalCalo/Configuration/python/ecalLocalRecoSequenceCosmics_cff.py?view=markup Can't connect to cmssw.cvs.cern.ch:80 (Bad hostname)

Clustering

The ECAL clustering sequences are defined in RecoEcal/Configuration:

  • collisions (HEAD version):
More  Less  Failed to include URL http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/CMSSW/RecoEcal/Configuration/python/RecoEcal_cff.py?view=markup Can't connect to cmssw.cvs.cern.ch:80 (Bad hostname)
  • cosmics (HEAD version):
More  Less  Failed to include URL http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/CMSSW/RecoEcal/Configuration/python/RecoEcalCosmics_cff.py?view=markup Can't connect to cmssw.cvs.cern.ch:80 (Bad hostname)

How to run the local reconstruction

How to run a modified local reco sequence inside the standard CMS reco sequence

  • setup your CMSSW environment
  • use the cmsDriver.py tool produce a config file to run the standard reconstruction sequence (on RAW data, without HLT):
         # example for cosmics data
         cmsDriver.py reco --data --scenario cosmics -s RAW2DIGI,RECO --conditions FrontierCoitions_CMS.GlobalTag,CRAFT_V1::All \
                 --eventcontent=FEVT --no_output --no_exec
    
         # example for MC data
         cmsDriver.py reco -s RAW2DIGI,RECO --conditions FrontierCoitions_CMS.GlobalTag,CRAFT_V1::All \
                 --eventcontent=FEVT --no_output --no_exec
         
    the global tag CRAFT_V1 is not valid anymore. To find the appropriate tag (data/MC) look at the list in the SWGuideFrontierConditions twiki page Before running the config file just produced remember to modify the input file, the number of events to be read (the default is 1) etc.
  • get the package RecoLocalCalo/Configuration where the sequences are defined:
         # if not done already do
         eval `scramv1 run -(c)sh`
         addpkg RecoLocalCalo/Configuration
         
  • modify the sequence or the event content according to your wishes. Both are defined in RecoLocalCalo/Configuration/python with self-explaining names

Example: modify the cosmic sequence to use the weight method to reconstruct the recHits

In the local reconstruction sequence for cosmics data, the ECAL uncalibratedRecHits are produced using

  • the fit method to reconstruct amplitude/time (ecalFixedAlphaBetaFitUncalibRecHit)
  • the weight method to reconstruct amplitude/time (ecalWeightUncalibRecHit)
The ECAL recHit are produced only from the ecalFixedAlphaBetaFitUncalibRecHit. If you want to have the ecalRecHit produced from the ecalWeightUncalibRecHit you can do the following:

  • perform the steps described above in this section
  • open RecoLocalCalo/Configuration/python/ecalLocalRecoSequenceCosmics_cff.py
  • change
         ecalRecHit.EBuncalibRecHitCollection = 'ecalFixedAlphaBetaFitUncalibRecHit:EcalUncalibRecHitsEB'
         ecalRecHit.EEuncalibRecHitCollection = 'ecalFixedAlphaBetaFitUncalibRecHit:EcalUncalibRecHitsEE'
         
    into
         ecalRecHit.EBuncalibRecHitCollection = 'ecalWeightUncalibRecHit:EcalUncalibRecHitsEB'
         ecalRecHit.EEuncalibRecHitCollection = 'ecalWeightUncalibRecHit:EcalUncalibRecHitsEE'
         
  • run your cfg file and enjoy. Be aware that you will only have recHits from ecalWeightUncalibRecHit, with this minimal modification you cannot have two collection of recHits.

Treatment of problematic channel (ongoing):

In the context of the discussion about reconstruction of ECAL problematic channels and propagation of the information along the reconstruction chain, find here a guideline document and collection of thoughts.

Channel status, Event status, Reconstruction actions, RecHit flagging and severity level

A special reconstruction is envisaged for problematic channels. A granular information, describing the problem, is stored in the DB (Channel Status) on a run basis. Info about the actual statuses for ECAL can be found here.

A cfg file will be used in the Reco to map channel statuses to action taken in the reconstruction (e.g. standard reconstruction, reconstruction with special weights, dead channel recovery, ...) . The action may depend also on event conditions (e.g. saturation, integrity errors, unpacking errors).

RecHits are flagged depending on the Channel status and Event status. Severity levels are available for downstream objects (SuperClusters, BasicClusters) to quantify the reliability of the energy information depending the RecHit included. This information will be retrieved dynamically

Channel status bits and values

Channel Status Bits Value Problem description Reco Action
1-5 0 channel ok standard reco
1 DAC settings problem, pedestal not in the design range standard reco
2 channel with no laser, ok elsewhere standard reco
3 noisy no reco
4 very noisy no reco
5-7 reserved for more categories of noisy channels --
8 channel at fixed gain 6 (or 6 and 1) no reco
9 channel at fixed gain 1 no reco
10 channel at fixed gain 0 (dead of type this) no reco
11 non responding isolated channel (dead of type other) no reco
12 channel and one or more neigbors not responding (e.g.: in a dead VFE 5x1 channel) no reco
13 channel in TT with no data link, TP data ok recovery from TP data
14 channel in TT with no data link and no TP data no reco
6 HV good/not good
7 LV on/off
8 DAQ in/out
9 TP readout on/off
10 Trigger in/out
11 Temperature ok/not ok
12 Humidity ok/not

Status 13 : a full 5x5 region with dead readout (DCC) but active trigger primitive (TCC) data

It is possible to perform recovery from neighbouring channels for status 3-11, but this is turned off in the local reco.

Event status

A channel status can be set also on an event-by-event basis depending on the result of the unpacking. Three cases are envisaged that can trigger special reconstructions

  • saturated cell --> recovery from the leading edge
  • data integrity errors --> digis are not produced from portions of the raw data that violate the ECAL raw data format rules. Collections of DetId are produced for each type of such violations, each DetId indicating the region of ECAL from which the corrupted data comes from. Action: find a way of propagating this to the reconstruction

RecHit flagging according to (special) reconstruction

The flags for a given recHit can be retrieved via the method EcalRecHit::recoFlags().
The method CaloRecHit::flags() returns the entire 32 bit flags_ field, which contains additional information (so you may get values different from the ones in the table below). To take advantage of the 32 bits available, the word flags_ is used both for flagging and for adding other informations, as the probability of the chi^2 of the pulse shape reconstruction, the energy of out-of-time events as estimated by allowing the event to be out of synch with respect to the clock (while the recHit energy is always reconstructed assuming the event in time).

ALERT! Do not rely on the flag ordering in your code

Flag kLabel Meaning
0 kGood Good: channel ok, the energy and time measurement are reliable (ChannelStatus=0-2 now. ChannelStatus=2 may evolve to Flag=3, when transparency changes become relevant)
1 kPoorShape Problematic: The energy is available from the UncalibRecHit, but approximate (bad shape, large chi2)
2 kOutOfTime Problematic: The energy is available from the UncalibRecHit (sync reco), but the signal is out of time
3 kPoorCalib Problematic: The energy is available from the UncalibRecHit, but the calibration of the channel is poor (to be retrieved from DB if needed)
4 kFaultyHardware Problematic: The energy is available from the UncalibRecHit, channel is faulty at some hardware level (e.g. works in fixed gain, noisy, ...). Further information is available in the DB (ChannelStatus=3-9) and not replicated in the flag.
5 kNoisy Problematic: The energy is available from the UncalibRecHit but the channel is noisy
6 kSaturated Saturated: Recovery fails, the channel is saturated (energy set at dynamic limit)
7 kLeadingEdgeRecovered Saturated: Recovery succeeds, energy estimated from the leading edge before saturation
8 kNeighboursRecovered Recovered: Saturated/isolated dead: energy estimated from neighbours (n case of saturation, it means that recovery from leading edge failed)
9 kTowerRecovered Recovered: Channel in TT with no data link, info retrieved from Trigger Primitive
10 kFake the signal in the channel is a fake (e.g. a so-called spike)
11 kDead Truly dead: Channel is dead and any recovery fails
12 kKilled For MC only: the channel in the real detector is dead.
13 kUnknown To easy the interface with functions returning flags

Mapping into severity levels

Severity levels for Jet/MET reconstruction
  • Channels with flags equal to 0 are mapped into severity 0
  • Channels with flags from 1 to 4 are mapped into severity 1
  • Channels with flags 5 and 6 are mapped into severity 2.
  • Channels with flag 7 are mapped into severity 2.
  • Channels with flag 8 are mapped into severity 3.
  • Channels located in regions which suffered of data integrity problems are signalled by the unpacker and are mapped into severity 3.
  • Channels in regions of the detector which were off are mapped into severity 3.

Initial prescription is that channels with severity >2 are not used in Jet/MET calculation.

Severity levels for e/gamma reconstruction
  • All (recovered) channels (flag<3) are used in the clustering.
  • A severity level is added to the clusters as the fraction of energy in the cluster belonging to problematic channels
  • This code is not yet deployed

How to retrieve severity levels for recHits

The HEAD of the class computing the severity level for recHits can be found following this link. An example (untested but conceptually right) of the usage is the following:

#include "RecoLocalCalo/EcalRecAlgos/interface/EcalSeverityLevelAlgo.h"

MyAnalyzer::MyAnalyzer(const edm::ParameterSet& iConfig) 
{
    ebRecHitsLabel_ = iConfig.getParameter< edm::InputTag > ("ebRecHitsLabel");
    eeRecHitsLabel_ = iConfig.getParameter< edm::InputTag > ("eeRecHitsLabel");
}

void MyAnalyzer::beginRun( cosnt edm::EventSetup & iSetup )
{
    // where edm::ESHandle<CMS.EcalChannelStatus> chStatus;
    iSetup.get<EcalChannelStatusRcd>().get(chStatus);
    // where const EcalChannelStatusCode * channelStatus;
    channelStatus = chStatus.product();
}


void MyAnalyzer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup)
{
    // retrieve the ECAL RecHitCollections
    edm::Handle<EcalRecHitCollection> ebRecHits_h;
    iEvent.getByLabel(ebRecHitsLabel_, ebRecHits_h);
    const EcalRecHitCollection * ebRecHits = ebRecHits_h.product();

    edm::Handle<EcalRecHitCollection> eeRecHits_h;
    iEvent.getByLabel(eeRecHitsLabel_, eeRecHits_h);
    const EcalRecHitCollection * eeRecHits = eeRecHits_h.product();
    
    // get the ECAL ChannelStatus from DB

    // get the severityLevel for all the ECAL DetId's
    // Barrel
    std::cerr << "BARREL --" << std::endl;
    for ( int i = 0; i < EBDetId::kSizeForDenseIndexing; ++i )
    {
            EBDetId id = EBDetId::unhashIndex( i );
            if ( id != EBDetId(0) ) {
                    std::cout << " id " << id.rawId() 
                        << " -> (" << id.ieta() << ", " << id.iphi() << ", " << id.zside() << ") " 
                        << EcalSeverityLevelAlgo::severityLevel( id, ebRecHits, channelStatus )
                        << "\n";
            }
    }
    // Endcap
    std::cerr << "ENDCAP --" << std::endl;
    for ( int i = 0; i < EEDetId::kSizeForDenseIndexing; ++i )
    {
            EEDetId id = EEDetId::unhashIndex( i );
            if ( id != EEDetId(0) ) {
                    std::cout << " id " << id.rawId() 
                        << " -> (" << id.ix() << ", " << id.iy() << ", " << id.zside() << ") "
                        << EcalSeverityLevelAlgo::severityLevel( id, eeRecHits, channelStatus )
                        << "\n";
            }
    }


    // -- get the severityLevel for the RecHits
    // (so only the reconstructed channels 
    // or dead/recovered ones not in ZS region)
    for( it = ebRecHits_->begin(); it != ebRecHits_->end(); ++it)
    {
        EcalRecHit rh = (*it);
        std::cout << "RecHit detId= " << rh.rawId() 
            << " energy= " << rh.energy()
            << " recoFlag= " << rh.recoFlag()
            << " severityLevel= " << EcalSeverityLevelAlgo::severityLevel( rh, channelStatus )
            << "\n";
    }
    // analogous for the endcap recHits
}

Recovery strategies

How to switch on a specific recovery

Recovery for a specific class of dead channels can be activated via the configuration file of the recHit producer: RecoLocalCalo/EcalRecProducers/python/ecalRecHit_cfi.py:

    recoverEBIsolatedChannels = cms.bool(True),
    recoverEEIsolatedChannels = cms.bool(False),  # not yet implemented
    recoverEBVFE  = cms.bool(False),              # not yet implemented
    recoverEEVFE  = cms.bool(False),              # not yet implemented
    recoverEBFE = cms.bool(True),
    recoverEEFE = cms.bool(False),                # not yet implemented

Trigger Towers with no data-link

A baseline (default) approach to the recovery of the information about the energy deposited in a TT with no data link is described. Some parameters (the energy scale and resolution of the TP data) are tunable ( add details). If the performance are strongly affected by this, a tuning can be attempted.

Metrics are defined to assess the impact of this approach for e/gamma and Jet/MET reconstruction. MET reconstruction is based on recHits (local deposits), while e/gamma are based on clusters (reginal deposits). A proper choice of the metrics allows to make the two studies almost independent. A tentative metric for e/gamma is defined by the size of the acceptance region around the TT with no data link. A tentative metric for JeT/MET is the amount of fake MET in QCD events.

RecHit action
Use TP data and assign energy to recHits after linearization as recHit=TP/25. Set different flags if TP is saturated or not saturated.

Impact on Jet/MET: The impact will be evaluated by studying Jet and missing energy in QDC events w/ and w/o recovered tower. Clustering steps are not relevant for JeT/MET performance. Any attempt to go beyond a democratic sharing of the energy in the individual channels is not expected to be rewarding. Tuning of TP scale/resolution may have impact and need to be addresses in the study.

Clustering (proposed baseline approach, not yet active)
  • 5x5 clusters:
    • clusters with seed xtal in regions external to the 9x9 matrix centered on the TT are ok.
    • clusters with seed xtal in the (9x9-5x5) ring are not made or are made but flagged as "cannotBeSeedCluster"

  • Superclusters:
    • Only clusters flagges as "cannotBeSeedClusters" are accepted to start SC
    • Energy internal to the 9x9 matrix can be added to SC (or not?), but SC need to be flagged.

We end up here with an inefficiency (reduced acceptance) of 1.5% in making SCs (as we prevent 81 xtals x 10 dead TT from being seed). There will also be a somewhat larger fraction, to be evaluated, of SCs with approximate energy estimate and el ID variables partly affected.

Impact on e/gamma:

  • Energy estimate: This was preliminary addressed in the analysis presented [[][here]]. The analysis can be finalized according to the above schema. The exact understanding of which degradation in energy resolution is acceptable is much dependent on the analysis. A baseline goal for ECAL DPG can be providing a flag for SC, with some info on how good the energy estimate is. Also it could be interesting to precisely define the size of the acceptance region for defined level of precisions in the energy reconstruction.

  • Electron id: This is in the POG are, but I can tentatively propose some considerations. Most of the variables for el.ID are based on the seed (5x5) clusters and will not be affected by the above procedure. One exception is the ECAL isolation, which integrate energy over a larger area. This integration may still be roughly valid with the dafault/democratic recovery of the recHit energy. A goal of the analysis can be to probe these conjecture and again end up with an exact definition of the size of the fiducial region for given level

Isolated non responding channels

* Baseline is NN recovery from neighbours (Stephanie). * Ongoing work on parametric description of transverse shower shape

Saturated cells

Add link to CMSSW and to Martina slides (or documents)

Responsible: FedericoFerri

Review status

-- FedericoFerri - 07-Dec-2009 add prompt reco and express stream sequences -- FedericoFerri - 03-Dec-2009 add reconstruction sequence description -- FedericoFerri - 06 Aug 2009 add how to change the local reco sequence within the CMS standard reco -- FedericoFerri - 22 Jul 2009
Topic attachments
I Attachment History Action Size Date Who Comment
PDFpdf EcalProblematicChannels.pdf r1 manage 51.5 K 2009-07-23 - 17:33 GiovanniFranzoni Roadmap for treatment of problematic channels i 31x
Edit | Attach | Watch | Print version | History: r15 < r14 < r13 < r12 < r11 | Backlinks | Raw View | WYSIWYG | More topic actions
Topic revision: r15 - 2019-06-15 - ThiagoTomei
 
    • Cern Search Icon Cern Search
    • TWiki Search Icon TWiki Search
    • Google Search Icon Google Search

    CMSPublic All webs login

This site is powered by the TWiki collaboration platform Powered by PerlCopyright & 2008-2020 by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
or Ideas, requests, problems regarding TWiki? use Discourse or Send feedback