fast_carpenter.define package¶
-
class
fast_carpenter.define.
Define
(name, out_dir, variables)[source]¶ Bases:
object
Creates new variables using a string-based expression.
There are two types of expressions:
- Simple formulae, and
- Reducing formulae.
The essential difference, unfortunately, is an internal one: simple expressions are nearly directly handled by numexpr, whereas reducing expressions add a layer on top.
From a users perspective, however, simple expressions are those that preserve the dimensionality of the input. If one of the input variables represents a list of values for each event (whose length might vary), then the output will contain an equal-length list of values for each event.
If, however, a reducing expression is used, then there will be one less dimension on the resulting variable. In this case, if an input variable has a list of values for each event, the result of the expression will only contain a single value per event.
Parameters: variables (list[dictionary]) – A list of single-length dictionaries whose key is the name of the resulting variable, and whose value is the expression to create it.
Other Parameters: - name (str) – The name of this stage (handled automatically by fast-flow)
- out_dir (str) – Where to put the summary table (handled automatically by fast-flow)
Example
variables: - Muon_pt: "sqrt(Muon_px**2 + Muon_py**2)" - Muon_is_good: (Muon_iso > 0.3) & (Muon_pt > 10) - NGoodMuons: {reduce: count_nonzero, formula: Muon_is_good} - First_Muon_pt: {reduce: 0, formula: Muon_pt}
See also
fast_carpenter.define.reductions
– for how reductions are handled and exactly what is valid.- numexpr: which is used for the internal expression handling.
-
class
fast_carpenter.define.
SystematicWeights
(name, out_dir, weights, out_format='weight_{}', extra_variations=[])[source]¶ Bases:
object
Combines multiple weights and variations to produce a single event weight
To study the impact of systematic uncertainties it is common to re-weight events using a variation of the weights representing, for example, a 1-sigma increase or decrease in the weights. Once there are multiple weight schemes involved writing out each possible combination of these weights becomes tedious and potentially error-prone; this stage makes it easier.
It forms the
nominal
weight for each event by multiplying all nominal weights together, then the specific variation by replacing a given nominal weight with its corresponding “up” or “down” variation.Each variation of a weight should just be a string giving an expression to use for that variation. This stage then combines these into a single expression by joining each set of variations with “*”, i.e. multiplying them together. The final results then use an internal
Define
stage to do the calculation.Parameters: - weights (dictionary[str, dictionary]) – A Dictionary of weight variations
to combine. The keys in this dictionary will determine how this
variation is called in the output variable. The values of this
dictionary should either be a single string – the name of the input
variable to use for the “nominal” variation, or a dictionary containing
any of the keys,
nominal
,up
, ordown
. Each of these should then have a value providing the expression to use for that variation/ - out_format (str) – The format string to use to build the name of the output variations. Defaults to “weight_{}”. Should contain a pair of empty braces which will be replaced with the name for the current variation, e.g. “nominal” or “PileUp_up”.
- extra_variations (list[str]) – A list of additional variations to allow
Other Parameters: - name (str) – The name of this stage (handled automatically by fast-flow)
- out_dir (str) – Where to put the summary table (handled automatically by fast-flow)
Example
syst_weights: energy_scale: {nominal: WeightEnergyScale, up: WeightEnergyScaleUp, down: WeightEnergyScaleDown} trigger: TriggerEfficiency recon: {nominal: ReconEfficiency, up: ReconEfficiency_up}
which will create 4 new variables:
weight_nominal = WeightEnergyScale * TriggerEfficiency * ReconEfficiency weight_energy_scale_up = WeightEnergyScaleUp * TriggerEfficiency * ReconEfficiency weight_energy_scale_down = WeightEnergyScaleDown * TriggerEfficiency * ReconEfficiency weight_recon_up = WeightEnergyScale * TriggerEfficiency * ReconEfficiency_up
- weights (dictionary[str, dictionary]) – A Dictionary of weight variations
to combine. The keys in this dictionary will determine how this
variation is called in the output variable. The values of this
dictionary should either be a single string – the name of the input
variable to use for the “nominal” variation, or a dictionary containing
any of the keys,