• Make the WW or ZZ util files by running make commands..

• Please refer to the instructions here for the ME calculation instruction

Instruction

• Get the looper code from CVS (here I assume that you have already set up your favorite CMSSW release)

• Create two soft links, one pointing to the ntuple location "data" and one pointing to "CORE"

• Compile code by running gmake

• Run script doAllHWW.C or doAllHZZ.C to produce the input files for the ME calculations in HWW and HZZ respectively

• • This looper creates a smurf ntuple for each process and one utility root file called either Util_HWW.root or for Util_HZZ.root, which contains the lepton efficiency, boost and fake rate related histograms.

• Files for the SmurfV6 selections using 41X
  • Location: /smurf/yygao/data/EPS/auxilliar/

Matrix Element Inputs in CMS2

• This page documents the procedure to generate the this input Smurf Ntuple and the utility histograms that are needed to do the ME calculations. The code can be browsed here.
• Please refer to the instructions here for the ME calculation instruction.*

• Instructions
  • Getting the looper code from CVS (here I assume that you have already set up your favorite CMSSW release)

• • This looper creates a smurf ntuple for each process and one utility root file called Util.root, which contains the lepton efficiency, boost and fake rate related histograms.

• Current tested working tag is wwVsHww_diLep2020_v3

• You need to create two soft links, one pointing to the ntuple location "data" and one pointing to "CORE"

• This looper creates one input file for later ME calculation for each process specified to run in the script, like WW_skimmednTuple.root
• It also creates one utility root file called Util.root, which contains the lepton efficiency and boost histograms as well as a dil mass distributions which are later used to read the event yields in ME.

Planned improvements

• The yields are currently read off manually in constructing the LR, this should be avoided
• The babyNtuple format should be changed to the Smurf format

• Run script doAll.C to produce the input files for the ME calculations,

• For each process (for example WW) you specified to run in the doAll.C, the script creates two files that are needed for later ME calculations
  • WW_skimmednTuple.root, which contains the kinematic observables stored in TTree
  • WW_MCUtil.root, which contains the lepton efficiency and boost histograms that are extracted using MC truth

Run ME Calculations to produce cross-sections and LR

Matrix Element Implementation in CMS2

Prepare root ntuples as the input to the ME calculations

• Getting the code from CVS (here I assume that you have already set up your favorite CMSSW release)

     cvs co -d CMS2/NtupleMacros/CORE UserCode/JRibnik/CMS2/NtupleMacros/CORE
     cd CMS2/NtupleMacros/CORE
     cvs up -r WW2010 CMS2.h CMS2.cc
     cd ../../../
     cvs co -d CMS2/NtupleMacros/HWWME UserCode/JRibnik/CMS2/NtupleMacros/HWWME
     cvs co -d CMS2/NtupleMacros/Tools UserCode/JRibnik/CMS2/NtupleMacros/Tools
     

   ln -s /tas/cms2 data
   ln -s ../CORE CORE
   

• To produce one baby for say WW process, run:

/afs/cern.ch/user/y/yygao/public/libmcfm.so.

• I suggest that you do this part on cmslpc-sl5. The code requires 32-bit libgfortran.so library. Unfortunately, I could not find 32 bit version of this library on UCSD cluster. Transferring from cmslpc does not work either b/c ucsd has gcc 4.3.4 compiler while cmslpc has 4.1.2. (gcc -v).

• Copy the mcfm library libmcfm.so here

• The arguments are:

• A few notes on the ME code

• • TEvtProb .cc - main class, generates random numbers, calls PhaseSpace .
  • See TUtil.cc line 539 on how pdf and mcfm ME functions are called.

Preparation of MCFM libraries (or building libmcfm.so)

• You must end up with a library libmcfm.so, which contains all mcfm functions. You can transfer it from cmslpc to ucsd now, I tried it and it worked.

TEvtProb .cc - main class, generates random numbers, calls PhaseSpace . See TUtil.cc line 539 on how pdf and mcfm ME functions are called.

Here I assume that you have already set up your favorite CMSSW release and set up CMS2.

Prepare root ntuples:

• The ME code is set up so that it takes flat root ntuples (babies) with event kinematics as an input, performs all event probability calculations and then outputs new file which is a clone of the original + an extra branch containing ME values.

• These babies are created from CMS2 ntuples using a piece of code which also applies event selection. Right now the amount of information stored in the babies is limited to what is needed for ME calculations. One could in principle expand. The code can be found on UCSD cluster in:

CMS2/NtupleMacros/WW/sergo

files you need are: branches.h TBitSet .cc TBitSet .hh doAll.C

• You will also need to create two soft links, one pointing to the ntuple location "data" and one pointing to "CORE"

• To produce one baby for say Wjets process, run:

       root -l doAll.C\(\"Wjets\"\)   
      

  this should create a file Wjets_skimmednTuple.root with events passing selection criteria.

* Proceed with other samples for data, backgrounds and signal. In the end you should have one ntuple file per process.

Preparation of MCFM libraries:

* Start by downloading the MCFM package, under SL5 current release is 5.8

      wget http://mcfm.fnal.gov/mcfm-5.8.tar.gz
      tar zxf tarballname.tgz
      cd MCFM
      ./Install
     

• now you need to modify compiler flags a bit (needed for 32 bit objects, not for 64), open makefile and make sure that the flags are: FFLAGS = -fno-automatic -fno-f2c -O0 -g -fPIC -m32 -march=i686 -I$(INCPATH)
• Compile:

     
        make
        cd obj
       

• Create shared library by running

       g++ -Wl,-soname,libmcfm.so -m32 -march=i686 -shared -o libmcfm.so *.o -L /home/cdfsoft/products/cern/2004/Linux+2.4-2.3.2/lib (replace with your path)
      

• You must end up with a library libmcfm.so, which contains all mcfm functions, you can load it and call these functions from your code.

Producing ME ntuples:

        *.cc, *.hh, *.DAT, *.C, foam, Pdfdata, Makefile, Linkdef.h
     

     root -l
     .x runME_v1.C("../Wjets_skimmednTuple.root",10,3,50000,1.0,0)
     

    1 - input file
    2 - random seed
    3 - smearing level, not used now
    4 - number of steps in the integration
    5 - error threshold
    6 - Mass, if 0 - calculate for all processes and Higgs mass hypothesis
     

-- SergoJindariani - 04 Jan 2011