dd/df3/fftjetproducer__cfi_8py_source.html

 import math

 import FWCore.ParameterSet.Config as cms


 from RecoJets.FFTJetProducers.fftjetcommon_cfi import *


 fftjet_default_recombination_scale = 0.5


 # FFTJet jet producer configuration

 fftjetJetMaker = cms.EDProducer(

     "FFTJetProducer",

     #

     # Label for the input clustering tree (must be sparse)

     treeLabel = cms.InputTag("fftjetpatreco", "FFTJetPatternRecognition"),

     #

     # Do we have the complete event at the lowest clustering tree scale?

     # Note that sparse clustering tree removes it by default, even if

     # it is inserted by the pattern recognition module.

     insertCompleteEvent = cms.bool(fftjet_insert_complete_event),

     completeEventScale = cms.double(fftjet_complete_event_scale),

     #

     # The initial set of scales used by the pattern recognition stage.

     # This is also the final set unless clustering tree construction

     # is adaptive. Needed here for reading back non-adaptive trees.

     InitialScales = fftjet_patreco_scales_50,

     #

     # Label for the produced objects

     outputLabel = cms.string("MadeByFFTJet"),

     #

     # Label for the input collection of Candidate objects

     src = cms.InputTag("towerMaker"),

     #

     # Type of the jets which will be produced (should be consistent with

     # the input collection). Valid types are "BasicJet", "GenJet", "CaloJet",

     # "PFJet", and "TrackJet". The algorithm might do different things

     # depending on the type. In particular, vertex correction may be done

     # for "CaloJet".

     jetType = cms.string("CaloJet"),

     #

     # Perform vertex correction?

     doPVCorrection = cms.bool(False),

     #

     # Label for the input collection of vertex objects. Meaningful

     # only when "doPVCorrection" is True

     srcPVs = cms.InputTag("offlinePrimaryVertices"),

     #

     # Anomalous calo tower definition (comes from RecoJets default)

     anomalous = fftjet_anomalous_tower_default,

     #

     # Magnitude correction factors (used only with gridded algorithms)

     etaDependentMagnutideFactors = cms.vdouble(),

     #

     # If a gridded algorithm is used, do we want to pick up the discretized

     # energy flow grid from the event record?

     reuseExistingGrid = cms.bool(False),

     #

     # If we do not reuse an existing grid, we need to provide

     # the grid configuration

     GridConfiguration = fftjet_grid_256_128,

     #

     # Maximum number of iterations allowed for the iterative jet

     # fitting. One-shot method is used if this number is 0 or 1.

     maxIterations = cms.uint32(1),

     #

     # Number of leading jets for which the iterative jet fitting must

     # converge before iterations are declared successful. This parameter

     # is not terribly meaningfule unless you know how many jets you expect

     # to get.

     nJetsRequiredToConverge = cms.uint32(10),

     #

     # The distance cutoff for the convergence. The distance between

     # the jets on two subsequent iterations must be less than this

     # cutoff in order to declare that the jet reconstruction has

     # converged. The distance function is defined by the "jetDistanceCalc"

     # parameter. Used only if "maxIterations" is larger than 1.

     convergenceDistance = cms.double(1.0e-6),

     #

     # Are we going to produce the set of constituents for each jet?

     # If we are not doing this, the code will run faster.

     assignConstituents = cms.bool(True),

     #

     # Are we going to resum constituents to calculate jet 4-vectors?

     # This only makes sense when a gridded algorithm is used in the

     # crisp 4-vector recombination mode to determine jet areas (note

     # that "recombinationDataCutoff" parameter should be negative),

     # and resumming is used to emulate vector algorithm recombination.

     resumConstituents = cms.bool(False),

     #

     # Noise sigma parameter for the background functor (the interface

     # to noise modeling is likely to be changed in the future)

     noiseLevel = cms.double(0.15),

     #

     # Number of clusters requested. Works with both "locallyAdaptive"

     # and "globallyAdaptive" resolution schemes.

     nClustersRequested = cms.uint32(4),

     #

     # Maximum eta for gridded recombination algorithms. Grid cells

     # with eta values ou t

     gridScanMaxEta = cms.double(fftjet_standard_eta_range),

     #

     # Are we going to use gridded or vector algorithm? Vector algoritms

     # are slightly more precise (no binning uncertainty introduced). However,

     # jet-by-jet jet areas can be calculated only by gridded algorithms.

     useGriddedAlgorithm = cms.bool(False),

     #

     # The recombination algorithm used. For vector algorithms, possible

     # specifications are:

     #   "Kernel"     -- use 4-vector recombination scheme

     #   "EtCentroid" -- use Et centroid (or "original Snowmass") scheme

     #   "EtSum"      -- set the jet direction to the precluster direction

     # For gridded algorithms additional specifications are available:

     # "FasterKernel", "FasterEtCentroid", and "FasterEtSum". See the

     # comments in the "FasterKernelRecombinationAlg.hh" header of the

     # FFTJet package for limitations of those faster algorithms.

     recombinationAlgorithm = cms.string("Kernel"),

     #

     # Are we going to utilize crisp or fuzzy clustering?

     isCrisp = cms.bool(True),

     #

     # A parameter which defines when we will attempt to split the energy

     # of a calorimeter cell if it is unlikely to belong to any jet and

     # to the noise. Works with Et-dependent membership functions only.

     # The default value of 0 means don't split, just assign this energy

     # deposition to the unclustered energy.

     unlikelyBgWeight = cms.double(0.0),

     #

     # The data cutoff for the gridded algorithms. Set this cutoff

     # to some negative number if you want to calculate jet areas

     # (this can also be done by turning on pile-up calculation

     # as a separate step.) Set it to 0 or some positive number

     # if you want to improve the code speed.

     recombinationDataCutoff = cms.double(0.0),

     #

     # The built-in precluster selection for subsequent jet reconstruction

     # can be performed according to the following schemes which, basically,

     # describe how the resolution of the Gaussian filter is chosen:

     #  "fixed"            -- use the same user-selected resolution across

     #                        the whole eta-phi space

     #  "maximallyStable"  -- pick up a single resolution according to

     #                        a jet configuration stability criterion

     #  "globallyAdaptive" -- pick up a single resolution which gives

     #                        a desired number of jets

     #  "locallyAdaptive"  -- use different resolutions in different parts

     #                        of the eta-phi space in order to maximize

     #                        a certain optimization criterion

     resolution = cms.string("fixed"),

     #

     # Scale parameter for the "fixed" and "locallyAdaptive" resolution schemes

     fixedScale = cms.double(0.15),

     #

     # Minimum and maximum stable scales for the "maximallyStable"

     # resolution scheme. Value of 0 means there is no limit, and

     # all scales in the clustering tree are considered.

     minStableScale = cms.double(0.0),

     maxStableScale = cms.double(0.0),

     #

     # Stability exponent for the "maximallyStable" resolution scheme

     stabilityAlpha = cms.double(0.5),

     #

     # The precluster discriminator which works together with the

     # resolution selection scheme

     PeakSelectorConfiguration = cms.PSet(

         Class = cms.string("SimplePeakSelector"),

         magCut = cms.double(0.1),

         driftSpeedCut = cms.double(1.0e100),

         magSpeedCut = cms.double(-1.0e100),

         lifeTimeCut = cms.double(-1.0e100),

         NNDCut = cms.double(-1.0e100),

         etaCut = cms.double(1.0e100)

     ),

     #

     # The jet membership function

     jetMembershipFunction = fftjet_jet_membership_cone,

     #

     # The noise membership function

     bgMembershipFunction = fftjet_noise_membership_smallconst,

     #

     # The recombination scale function

     recoScaleCalcPeak = cms.PSet(

         Class = cms.string("ConstDouble"),

         value = cms.double(fftjet_default_recombination_scale)

     ),

     #

     # The function which calculates eta-to-phi bandwidth ratio

     # for the jet membership function. If the ratio is set to 0,

     # the "setScaleRatio" membership function method will never

     # be called, and the default ratio built into the membership

     # functionwill be used instead.

     recoScaleRatioCalcPeak = fftjet_peakfunctor_const_zero,

     #

     # The function which calculates the factor to be multiplied by

     # the membership function

     memberFactorCalcPeak = fftjet_peakfunctor_const_one,

     #

     # The following parameters must be specified if "maxIterations" value

     # is larger than 1. They are used in the iterative mode only.

     #  recoScaleCalcJet = ,

     #  recoScaleRatioCalcJet = ,

     #  memberFactorCalcJet = ,

     #  jetDistanceCalc = ,

     #

     recoScaleCalcJet = cms.PSet(

         Class = cms.string("ConstDouble"),

         value = cms.double(fftjet_default_recombination_scale)

     ),

     recoScaleRatioCalcJet = fftjet_peakfunctor_const_one,

     memberFactorCalcJet = fftjet_peakfunctor_const_one,

     jetDistanceCalc = fftjet_convergence_jet_distance,

     #

     # Are we going to estimate the pile-up using actual jet shapes?

     # Note that the following _must_ be defined if we want to do this:

     #   recoScaleCalcJet, recoScaleRatioCalcJet, memberFactorCalcJet,

     #   PileupGridConfiguration, and pileupDensityCalc

     calculatePileup = cms.bool(False),

     #

     # If the pile-up is estimated, do we want to subtract it?

     subtractPileup = cms.bool(False),

     #

     # If the pile-up is both estimated and subtracted, do we want to use

     # the 4-vector pile-up subtraction scheme? (The alternative is based

     # on scaling the jet Pt).

     subtractPileupAs4Vec = cms.bool(False),

     #

     # Source of the pile-up energy flow data

     pileupLabel = cms.InputTag("pileupestimator", "FFTJetPileupEstimatePF"),

     #

     # Label for GenJet collection in the "fromGenJets" resolution mode

     genJetsLabel = cms.InputTag("fftgenjetproducer", "MadeByFFTJet"),

     #

     # Max number of preclusters. Does not take into account the possibility

     # of further precluster removal by setting its membership factor to 0.

     maxInitialPreclusters = cms.uint32(2147483647),

     #

     # Parameters related to pileup shape fetching from DB

     pileupTableRecord = cms.string("pileupTableRecord"),

     pileupTableName = cms.string("pileupTableName"),

     pileupTableCategory = cms.string("pileupTableCategory"),

     loadPileupFromDB = cms.bool(False)

 )

Config

fftjetcommon_cfi