Les Houches

# These are the input objects for the analysis code.
# Syntax: 
#      name    type (see below)
# A well formulated comment behind each object should unambiguously state what this object is
# such that a _human_ knows what this object corresponds in his/her code
 
BLOCK ANALYSISINPUT
  jets      l<jet>      #   p4,pt>20    alg=anti-kt    R=0.4    b_prob,eff=(60,70,80)   
  elecs     l<el>       #   loose, isotags 1=tracks,dr0.2, 2=...
  muons     l<mu>       #
  etmiss    v           #
 
 
# All functions that have to be used later must be defined here.
# The declaration is similar to typical type-based declaration: It has to be
#  specified what the name of the function is, what objects go in and what comes out.
#
# Syntax:  Function_name   input_type_1  input_type_2   input_type_3 ... output_type
# Rules:
#        - input_types and output_type can be 
#           - 's' for scalars/numbers, 
#           - 'v' for LorentzVectors,        
#           - 'b' for booleans
#           - 'c' for characters/strings
#           - any of the objects defined in the 'object' block
#           - l<type> to denote a list of objects of common type <type>.
#        - People will comment with a link to a resource where the exact definition
#          of that function can be found, in text definiton and a working example in a programming language of choice
#        - 2 functions can have the same name if they have different input types
 
BLOCK ANALYSISFUNCTIONS
  mT               v    v    s             # https://twiki.cern.ch/twiki/bin/view/XXPublic/LHA/Definitions/m_T
  amT2             v    v    s             # https://twiki.cern.ch/twiki/bin/view/XXPublic/LHA/Definitions/am_T2
  mT2tau           v    v    s             # https://twiki.cern.ch/twiki/bin/view/XXPublic/LHA/Definitions/m_T2_tau
  mHadTop          ?    ?    ?             # https://twiki.cern.ch/twiki/bin/view/XXPublic/LHA/Definitions/m_had_top
  HTMissSig        ?    ?    ?             # https://twiki.cern.ch/twiki/bin/view/XXPublic/LHA/Definitions/HTmisssig
 
  # s denotes the working point efficiency
  filter_no_bjets      l<jet>  s      l<jet>   # https://twiki.cern.ch/twiki/bin/view/XXPublic/BJetDefinitionSource
  filter_bjets         l<jet>  s      l<jet>   # https://twiki.cern.ch/twiki/bin/view/XXPublic/BJetDefinitionSource
  filter_taujets       l<jet>  s      l<jet>   # https://twiki.cern.ch/twiki/bin/view/XXPublic/TauJetDefinitionSource
  filter_medium_elec   l<elec> l<elec>         # https://twiki.cern.ch/twiki/bin/view/XXPublic/ElectronIDSource
  filter_tight_elec    l<elec> l<elec>         # https://twiki.cern.ch/twiki/bin/view/XXPublic/ElectronIDSource
 
  #                    input  whichsource  dr       ptmin   maxval   output
  filter_iso_abs       l<el>  s    s   s   s   l<el>     # https://twiki.cern.ch/twiki/bin/view/XXPublic/Definitions/Isolation
  filter_iso_rel       l<el>  s    s   s   s   l<el>     # https://twiki.cern.ch/twiki/bin/view/XXPublic/Definitions/Isolation
  filter_iso_abs       l<mu>  s    s   s   s   l<mu>     # https://twiki.cern.ch/twiki/bin/view/XXPublic/Definitions/Isolation
  filter_iso_rel       l<mu>  s    s   s   s   l<mu>     # https://twiki.cern.ch/twiki/bin/view/XXPublic/Definitions/Isolation
 
  trigger              l<el>  l<mu>  l<jet>  v           # https://twiki.cern.ch/twiki/bin/view/XXPublic/Definitions/SingleLepTrigger + EtMissTrigger
  dataquality          l<jet> v                          # Tuned to a constant efficiency of 99.7%, see here: https://twiki.cern.ch/twiki/bin/view/XXPublic/EventCleaning/  
 
# These functions are like normal functions, but as these are always needed one might find a 
#  way to globally use them without continuously redefining them
  sum               s   s   s
  diff              s   s   s
  prod              s   s   s
  quot              s   s   s
  pow               s   s   s
  random            s 
 
  overlap_removal   l<v>   l<v>   s     v
  delta_phi         v      v      s
  delta_r           v      v      s
  ptmin             l<v>   s      l<v> 
  etarange          l<v>   s      s     l<v>
  combine           l<v>   l<v>   l<v>
  take_leading_n    l<v>   s      l<v>
 
 
 
# The Preselection block only trims existing objects or define new objects by applying functions on existing ones.
# It might be hard to read at first, but one just has to imagine the column
#      x     f     y     z
# with the following extra characters
#      x  =  f  (  y  ,  z  )
# i.e. one associated the object in col1 with the result of the function in col2, putting in the objects that come after.
#
# Syntax:   new_object function parameter1   parameter2  ...
# Rules:
#     - each function must be defined in the function block
#     - parameters must match the parameter type definition in the function block  
#     - parameters must be numbers, strings, objects that have been defined in previous lines or in the 'object' block
#     - Every TLorentzVector function  "Double_t Fun() const" can be accessed by v.fun (eg. v.m, v.pt, v.px, v.costheta
#        
#     - With vectors one can do
#        vectors.n   returns size
#        vectors.3   returns the third(!) object in the list
#        vectors.8   returns a zero object if vectors contains less than 8 entries
#     - Cut-Logic should make sure that the last rule does not produce rubbish (see mT example) 
#     - objects and functions can have the same name as the syntax does clearly distinguish between the two
 
BLOCK ANALYSISPRESELECTION
  # Kinematic Cuts on the loose baseline and the signal objects
  jets        ptmin           jets        20 
  jets        etarange        jets        -2.5       2.5
  elecs_l     ptmin           elecs       7   
  elecs_l     etarange        elecs_l     -2.47      2.47  
  elecs_m     filter_elecs_m  elecs_l
  elecs_m     ptmin           elecs_m    10  
  muons_l     ptmin           muons      6 
  muons_l     etarange        muons      -2.4       2.4
  muons_m     ptmin           muons      10  
 
  # overlap removals between bjets, nonbjets and leptons
  nob_jets        filter_no_bjets   jets        70
  b_jets          filter_bjets      jets        70
  no_bjets        overlap_removal   no_bjets    elecs_m   0.2
  elecs_m         overlap_removal   elecs_m     no_bjets  0.4
  elecs_m         overlap_removal   elecs_m     bjets     0.2
  elecs_m         overlap_removal   elecs_m     tau_jets  0.2
  muons_m         overlap_removal   muons_m     jets      0.4
  tau_jets_l      filter_taujets    "loose"     jets   
  tau_jets        filter_taujets    "tight"     jets   
  tau_jets        overlap_removal   tau_jets    elecs_l  0.2
 
  # choose signal leptons which have to pass isolation conditions
  elecs_t        ptmin              elecs_m   25
  elecs_t        filter_tight_elec  elecs_t   
  elecs_t        filter_iso_rel     "tracks"      0.2    0.5   0.1
  muons_m        filter_iso_abs     "tracks"      0.2    0.5   1.8
 
  # combine electrons and muons to leptons
  leptons_l      combine            muons_l       muons_l
  leptons_l      ptmin              leptons_l     10
  leptons        combine            elecs_t       muons_m
  leptons        ptmin              leptons       25
 
  # find the leading 4 jets
  leading_jets   take_leading_n     jets          4
  leading_bjets  filter_bjets       leading_jets  70
 
  # Calculate some advanced kinematical quantities
  HT             sum         jets.1.pt   jets.2.pt
  HT             sum         HT          jets.3.pt
  HT             sum         HT          jets.4.pt
  sqrtHT         sqrt        HT
  EtoverHT       quot        etmiss.pt   sqrtHT
  dPhi_j1_miss   dPhi        jets.1      etmiss
  dPhi_j2_miss   dPhi        jets.2      etmiss
  mT             mT          etmiss      leptons.1
  amT2           amT2        ?           ?
  mHadTop        mHadTop     ?           ?
  mT2Tau         mT2Tau      ?           ?
  HTMissSig      HTMissSig   ?           ?
 
  # Find overall efficiency for event
  trigeff        trigger     elecs_l     muons_l   jets   etmiss
  cleaningeff    dataquality elecs_l     muons_l   jets   etmiss  
  eventeff       prod        trigeff     cleaningeff  
  trigrand       random
  ....
 
# CUT blocks contain combinations of boolean statements
# Syntax:
#    Variable   operator   Value
# Rules:
#    - operator:  <, <=, =, >, >=, !=
#    - allowed Variables are: 
#       - input objects
#       - everything defined in the preselection block
#       - a preceeding CUT can be condidered as a Boolean
#    - functions cannot be used here. If the result of a function is needed, it must be evaluated in the preselection block
#    - there can be more than one condition in one CUT. Obviously this means that all conditions have to be fulfilled            
 
CUT  common
  leptons.n   =   1
  leptons_l.n =   1
  jets.n      >=  4
  etmiss.pt   >   100
 
 
CUT leadjets_60to25
  jets.1.pt   > 60
  jets.2.pt   > 60
  jets.3.pt   > 40
  jets.4.pt   > 25
 
CUT leadjets_80to25
  jets.1.pt   > 80
  jets.2.pt   > 60
  jets.3.pt   > 40
  jets.4.pt   > 25
 
CUT leadjets_100to25
  jets.1.pt   > 100
  jets.2.pt   > 80
  jets.3.pt   > 40
  jets.4.pt   > 25
 
CUT tN_diag
  common          =  True
  leadjets_60to25 =  True
  leading_bjets.n >= 1
  mT              > 100
  mHadTop         > 130
  mHadTop         < 205
  taujets.n       = 0
  dRbl            < 2.5
  EtoverHT        > 5
  dPhi12          = True
 
 
CUT tN_med
  common          =  True
  leadjets_80to25 =  True
  leading_bjets.n >= 1
  etmiss.pt       > 200
  mT              > 140
  amT2            > 170
  mHadTop         > 130
  mHadTop         < 195
  HTMissSig       > 12.5
  dPhi12          = True
 
 
CUT tN_high
  common          =  True
  leadjets_80to25 =  True
  leading_bjets.n >= 1
  etmiss.pt       > 320
  mT              > 200
  amT2            > 170
  mT2tau          > 120
  mHadTop         > 130
  mHadTop         < 250
  dRbl            < 3.0
  HtMissSig       > 12.5
 
# Cuts are interpreted as "remove event if it fails this". However, some conditions might just
# apply a weight to the event. These can be stated in the following block
# This can also be used for general event re-weighting e.g in the case of jet matching
# Syntax:
#      Cut   weight
# Rules:
#      - Cut must correspond to a CUT block
#      - weight must be a scalar, can be a variable though
 
BLOCK WEIGHTS
  common   eventeff
 
 
 
# BINNING blocks simplify exclusive bin-cuts and easily identify orthogonal regios
# Syntax:
#    BINNING (somename)
#      Cut        (name of cut after which binning is applied)
#      Parameters  (parameter1 to bin),(parameter2 to bin),...
#      New-Cutname1   bin1_min1,bin1_min2,...   bin1_max1,bin1_max2,...
#      New-Cutname2   bin2_min1,bin2_min2,...   bin2_max1,bin2_max2,...
#      ...
# Rules:
#    - Cut and Parameter must be valid, see above
#    - New-Cutname1 is a new Cut just like it was defined via a "CUT " block
#    - -inf and inf for "everything less/more than"
#    - Bins don't have to be orthogonal. Still it is easy to automatically check orthogonality a posteriori
 
 
BINNING tN_diag_mTEtMiss
  Cut       tN_diag
  Parameter mT,etmiss
  tN_diag_g100_g60   100,60   125,90
  tN_diag_g100_g90   100,90   125,120
  tN_diag_g100_g120  100,120  125,150
  tN_diag_g100_g140  100,150  125,inf
  tN_diag_g125_g60   125,60   150,90
  tN_diag_g125_g90   125,90   150,120
  tN_diag_g125_g120  125,120  150,150
  tN_diag_g125_g140  125,150  150,inf
  tN_diag_g150_g60   150,60   inf,90
  tN_diag_g150_g90   150,90   inf,120
  tN_diag_g150_g120  150,120  inf,150
  tN_diag_g150_g140  150,150  inf,inf
 
 
# Experimental Results are written in the following block
# Syntax:
#    SRname  Obs   Bkg   Bkgerr1   Bkgerr2  Bkgerr3 ...
# Rules:
#    Each SRname must correspond to a cut from above
BLOCK ExpResults:
  tN_diag_g100_g60   3452   3452   59
  tN_diag_g100_g90   1712   1720   161    
  tN_diag_g100_g120  313    295    50
  tN_diag_g100_g140  201    235    34
  tN_diag_g125_g60   2018   2018   45 
  tN_diag_g125_g90   768    767    80
  tN_diag_g125_g120  117    136    22
  tN_diag_g125_g140  163    152    30
  tN_diag_g150_g60   2543   2543   50  
  tN_diag_g150_g90   647    684    79
  tN_diag_g150_g120  98     13     101
  tN_diag_g150_g140  217    236    29
  tN_med             12     13.0   2.2
  tN_high            5      5.0    1.0
 
# Cutflows show events after consecutive evaluation of conditions
# Syntax:
#    Parameter Operator Value   EventsAfterCut1   Uncertainty   "Description in LateX Format"
# Rules:
#    - Parameter operator Value combinations: See above
#    - Cuts are applied one after another
#    - 
 
CUT mHadTopRange
    mHadTop         > 130
    mHadTop         < 205   
 
CUTFLOW  tN_diag_echannel
    True             =  True     200000   0   "Initial Events"
    trigrand         <  trigeff  113762   ?   "Trigger"
    leptons_l.n      =  1        28785    ?   "Lepton (exactly 1 baseline)"
    leptons.n        =  1        19875    ?   "Lepton (exactly 1 signal)"
    jets.n          >=  3        17959    ?   "At least 3 jets $\geq$ 25 GeV"
    jets.n          >=  4        13682    ?   "At least 4 jets $\geq$ 25 GeV"
    jets.1.pt       >=  60       12804    ?   "jet1pt $\geq$ 60"
    jets.2.pt       >=  60       9489     ?   "jet2pt $\geq$ 60"
    jets.3.pt       >=  40       8556     ?   "jet3pt $\geq$ 40"
    leading_bjets.n >=  1        7192     ?   "btag(70) >= 1"
    dPhi_j1_miss    >=  0.8      6611     ?   "dPhi(jet1, etmiss) >= 0.8"
    dPhi_j1_miss    >=  0.8      5147     ?   "dPhi(jet2, etmiss) >= 0.8"
    etmiss.pt       >=  150      1314     ?   "Etmiss >= 150"
    EtoverHT        >=  5        1314     ?   "Etmiss/sqrtHT >= 5"
    mT              >=  140      446      ?   "mT >= 140 GeV"
    mHadTopRange    =   True     283      ?   "mHadTop in 130, 205"
    taujets_l.n     =   0        257      ?   "veto on loose Taus"