-- SudhirMalik - 09 Jan 2009 pat_logo.jpg

4.2 CMSSW Analysis Starter Kit

Detailed Review status


See the starter kit in the news! Symmetry Magazine article on Starter Kit.

Link to latest prescriptions for various releases.

This page is intended for pedagogical introduction to the StarterKit and PAT. If you want the latest, greatest prescription, please see:


Authors (alpha order):

  • Steven Lowette <steven.lowette@cernSPAMNOT.ch>
  • Petar Maksimovic <petar@jhuSPAMNOT.edu>
  • Salvatore Rappoccio <rappocc@fnalSPAMNOT.gov>
  • Elizabeth Sexton-Kennedy <sexton@fnalSPAMNOT.gov>
  • Eric Vaandering <ewv@fnalSPAMNOT.gov>
  • Guofan Hu <Guofan.Hu@cernSPAMNOT.ch>
  • David Bjergaard <davidb@cernSPAMNOT.ch>


What is the StarterKit?

  • Focus: to create and implement the StarterKit, designed to facilitate "fast" analysis, to move from conception to a "reasonable" histogram within a day.
  • Who is the target audience?: Anyone who wants to get a reasonable start on analysis, including professors, new grad students, theorists, postdocts, those unfamiliar with C++/ROOT/CMSSW, and many more!
  • What other tools are available?: There are many other tools available for analysis in CMSSW, and the Physics Analysis Toolkit (PAT) is an attempt to consolidate them. We utilize the PAT as an analysis model. While there are other options available, this is the recommended versions for newcomers. We strongly encourage people to use the PAT for all of their analysis efforts, to avoid duplication of effort and to use well-understood objects and algorithms that are "blessed" by the Detector Performance Groups (DPG), Physics Object Groups (POG) and Physics Analysis Groups (PAG).
  • See us in the news!: Symmetry magazine has run a piece on the CMS Starter Kit here: http://www.symmetrymagazine.org/cms/?pid=1000590

Structure of the StarterKit

The StarterKit is a group of C++ objects along with corresponding plugins and configuration files to plot specific examples. It is based on the Physics Analysis Toolkit (PAT) described in detail here:

The prescriptions are based on the PAT prescriptions as shown here:

The StarterKit has the following functionality:

  • Will perform "common" plots for variables in the analysis such as 4-vector quantities and matching variables for detector objects.
  • A tiered structure of output, whereas the user can specify to simply make plots, perform simple skims, or write out a subset of the PAT and/or AOD.
  • Can automatically make plots for CompositeCandidate objects and "drill down" to the constituents recursively.
  • Provides user control for histogram binning, etc. This will eventually be generalized using the ExpressionParser functionality.

Our programming to do list includes:

  • Implementation of more complex examples.
  • Generic kinematic fitting of arbitrary constituents.
  • A validation suite to perform CRON jobs for day-to-day monitoring.
  • Extensive FWLite examples for performing analysis.
  • Automatic ntuplization of composite candidates.

CMSSW in 90 seconds or less

If you've been following the workbook all along, this should be "old news" to you, but here is the "quick and dirty" introduction for the impatient user. CMSSW stands for "CMS Software", and is a coding framework for the high level trigger, the reconstruction, and the analysis all at the same time. This is a novel approach for a collaboration of this size. It creates "projects" in subdirectories based on static code "tags" (from CVS). It allows us to modularize the performance so that specific tags can be studied and compared.

The StarterKit makes a new "package" in a directory in your home area. It will check out some code and compile it, and you can run a program on a predefined set of output and check against the "correct" answer to make sure you're starting from a good place.

Full details on the CMSSW framework can be found here: https://twiki.cern.ch/twiki/bin/view/CMS/WorkBookCMSSWFramework

A 30 second introduction to scram and some commands can be found here: https://twiki.cern.ch/twiki/bin/view/CMS/WorkBookScramV1Intro

Updated infrastructure

The StarterKit has undergone an infrastructure change in 2.1.4. We have now separated the StarterKit into three different plugins:

  • PatAnalyzerSkeleton : This provides a skeleton analyzer that will loop over PAT objects and make a simple histogram.
  • PatAnalyzerKit : This provides the functionality of the 1.6.x version of the StarterKit plugin.
  • CompositeKit : This will histogram an arbitrary collection of CompositeCandidates.

There has also been a restructuring of the code status. Previously it was designed such that the user would inherit directly from the EDM plugin StarterKit, and enhance plots using that hierarchy. This was not very performant and required users to carry around large libraries that contained the EDProducer libraries. Instead, a better solution has been worked out, so now the StarterKit has a "helper" class, PatKitHelper, which will do the majority of the plotting legwork for the plugins. To obtain the plots from this package, it is recommended to simply include this class as described below.

Class structure:


  • PatAnalyzerSkeleton: EDAnalyzer to show how to only pull out the PAT objects and loop over them.
  • PatAnalyzerKit: EDProducer to drive PatKitHelper.
  • PatKitHelper: Workhorse to do the plotting for plugins.
  • PhysicsHistograms: Contains and drives standard Histo objects for the various object types.
  • HistoMuon, HistoElectron, HistoMET, HistoJet, HistoPhoton, HistoTau: Classes derived from HistoGroup to implement specific objects including PhysVarHisto matching variables.
  • HistoGroup: Object to plot 4-vectors using PhysVarHisto.
  • PhysVarHisto: "Smart" histogram which can also ntuplize.

Code overview

The StarterKit code overview can be found here:



We assume here that a user has gone through the following workbook that talks about setup:


To set up a new area and run

   # set up CVS environment
   cmscvsroot CMSSW
   # login to CVS server. Password is "98passwd"
   cvs login
   # make a directory for the Starter Kit
   mkdir StarterKit
   cd StarterKit

   # create a new project area
   scramv1 p CMSSW CMSSW_2_1_9
   cd CMSSW_2_1_9/src/

   # Get the Starter Kit
  cvs co -r V02-02-07 PhysicsTools/StarterKit

   # build
   scramv1 b

   # run
   cd PhysicsTools/StarterKit/test
   cmsRun PatAnalyzerSkeleton_cfg.py >& skoutput.txt &
   tail -f skoutput.txt

Please not the following two comments.

Comment 1: The process to open, read and run over a data file is not instantaneous. It takes few seconds to open and begin reading the file. So keep looking at the output of the file skoutput.txt as it grows. If your job is complete, then skoutput.txt file should read the following at the end (By the way, you can look straight at the end of this file by doing tail skoutput.txt otherwise you have to open the file and scroll down).


MessageLogger Summary

 type     category        sev    module        subroutine        count    total
 ---- -------------------- -- ---------------- ----------------  -----    -----
    1 HemisphereAlgo       -w PATHemispherePro                       3        3
    2 fileAction           -s PoolSource:sourc                       2        2
    3 fileAction           -s PostSource                             1        1

 type    category    Examples: run/evt        run/evt          run/evt
 ---- -------------------- ---------------- ---------------- ----------------
    1 HemisphereAlgo       1/9704           1/9704           1/9704
    2 fileAction           pre-events       pre-events
    3 fileAction           1/9900

Severity    # Occurrences   Total Occurrences
--------    -------------   -----------------
Warning                 3                   3
System                  3

Comment 2: If you want to turn off the per event messages, like below, during processing a run,

Begin processing the 1st record. Run 1, Event 9701, LumiSection 666763 at 10-Nov-2008 11:11:26 CST 
Begin processing the 2nd record. Run 1, Event 9702, LumiSection 666763 at 10-Nov-2008 11:11:59 CST 
Begin processing the 3rd record. Run 1, Event 9703, LumiSection 666763 at 10-Nov-2008 11:11:59 CST 
Begin processing the 4th record. Run 1, Event 9704, LumiSection 666763 at 10-Nov-2008 11:11:59 CST 
you can change the option INFO to ERROR, as shown below, in PatAnalyzerKitSkeleton_cfg.py

#process.MessageLogger.cerr.threshold = 'INFO'
process.MessageLogger.cerr.threshold = 'ERROR'

To write every 10th event, for example, add/comment out the line as below

#process.MessageLogger.cerr.threshold = 'INFO'
process.MessageLogger.cerr.FwkReport.reportEvery = 10
#process.MessageLogger.cerr.threshold = 'ERROR'

Comment 3: You can run similarly the python scripts PatAnalyzerKitDemo_cfg.py and CompositeKitDemo_cfg.py .

To re-setup an old area and run

If you've already made a package and want to start again in the same package:

   cd StarterKit/CMSSW_2_1_9/src
   cd PhysicsTools/StarterKit/test
   cmsRun PatAnalyzerSkeleton_cfg.py >& skoutput.txt &

To update to a new Starter Kit CVS tag

If you've already built an older version of the Starter Kit, and would like to update to the most recent version, you can do

   cmscvsroot CMSSW
   # login to CVS server. Password is "98passwd"
   cvs login
   cd StarterKit/CMSSW_2_1_9/src
   cvs update -r V02-02-07 PhysicsTools/StarterKit
   scramv1 b

Detailed description of output and running


The configuration file is here:


Expected output will be:

  • PatAnalyzerSkeletonHistos.root : Root file containing output histograms.
  • skoutput.txt: Text file containing program output
  • PatAnalyzerSkeletonSkim.root: Root file containing skimmed events.

* If you run over hundreds of events you want to change the location of the output directory to a scratch area. For this you must edit the file PatAnalyzerSkeleton_cfg.py. To change number of events the relevant portion to change is the following. That is, change 200 events, to whatever number you want. Use -1 if you want to run over all the events.

# set the number of events
process.maxEvents = cms.untracked.PSet(
    input = cms.untracked.int32(200)
To change the location of the output directory, the relevant portion is the following:
# talk to output module
process.out = cms.OutputModule("PoolOutputModule",
    verbose = cms.untracked.bool(False),
    fileName = cms.untracked.string('PatAnalyzerSkeletonSkim.root')

Change this to read

# talk to output module
process.out = cms.OutputModule("PoolOutputModule",
    verbose = cms.untracked.bool(False),
    fileName = cms.untracked.string('/my_scratch/username/PatAnalyzerSkeletonSkim.root')

where "/my_scratch/username/" is the name of your scratch directory. For instance, if you are using lxplus, you can use "/tmp/[username]", and at Fermilab, you can use "/uscms_data/d1/[username]" after you create those directories.

Histogram Output

The first thing you should check is the Histogram file PatAnalyzerSkeletonHistos.root. If you copy the rootlogon.C file into your current directory, you can open root like this:

your_pc:%> root PatAnalyzerSkeletonHistos.root

The output will look something like this:

  *                                         *
  *        W E L C O M E  to  R O O T       *
  *                                         *
  *   Version  5.18/00a  20 February 2008   *
  *                                         *
  *  You are welcome to visit our Web site  *
  *          http://root.cern.ch            *
  *                                         *

ROOT 5.18/00a (branches/v5-18-00-patches@22235, Aug 27 2008, 21:17:00 on linux)

CINT/ROOT C/C++ Interpreter version 5.16.29, Jan 08, 2008
Type ? for help. Commands must be C++ statements.
Enclose multiple statements between { }.
TDR Style initialized
root [0] 
Attaching file PatAnalyzerSkeletonHistos.root as _file0...

You are now in the command line for the ROOT program. If you wish, you can turn on the statistics box by doing the following:

root [1] gStyle->SetOptStat(111111);

You can specify between one and six "1's", which correspond to the name, number of entries, mean, standard deviation, underflow, and overflow bins.

You can now execute the following command:

root [2] TBrowser b;

This will bring up a browser so that you can examine your PatAnalyzerSkeletonHistos.root file. It should look like this:


Click on the "ROOT Files" directory to descend into the next level, which should look like this:


Next click on PatAnalyzerSkeletonHistos.root.


Next click on "patAnalyzerSkeleton"


Finally click on "nmuons". This plots the number of muons in the sample.



If you execute the PatAnalyzerKit configuration file PatAnalyzerKitDemo_cfg.py, you'll obtain a different histogram and skim files, namely, PatAnalyzerKitHistos.root and PatAnalyzerKitSkim.root. We won't spend a lot of time on the clicking details since it is now assumed that you are familiar with them. Drill down PatAnalyzerKitHistos.root until you find a window that looks like this:


If you click on "muons", you see:


You'll notice that there are a great number of histograms here. This is what you get for free when using the PatKitHelper! These histograms are made to match the DQMOffline package here:


This allows the user to trivially examine the data quality of objects in their analysis.

Skim File Output

We now turn to the file in the scratch directory that you have been ignoring until now, /my_scratch/username/PatAnalyzerSkeletonSkim.root. This file (as all CMSSW files) can be opened directly in ROOT to examine its contents. First, we make sure that we have copied the rootlogon.C file to your home directory, and then type the following commands:

your_pc:%> root /my_scratch/username/PatAnalyzerSkeletonSkim.root

Be sure to substitute your scratch area that you wrote to before instead of "/my_scratch/username/PatAnalyzerSkeletonSkim.root".

Within ROOT, we type

root [1] TBrowser b;

You will see another TBrowser window that looks like this:

If you click on "ROOT files" again and click on "/my_scratch/username/PatAnalyzerSkeletonSkim.root", you will see a window that looks like this:


Click on "Events" and you will see this:


This is an image of the PAT Layer 1 output that we defined in our config files earlier. If you select a leaf (say, "selectedLayer1Muons"), you see something like this:


The actual object itself is stored on the leaf ending in ".obj". If you click that, you see


Finally, if you click on "caloIso", for instance, you see a plot of the calorimeter isolation of the muons in the sample:


Command Line Analysis

At this point, we can go back to the ROOT command line and do some more interesting things. If you type

root [3] Events->SetAlias("muons", "patMuons_selectedLayer1Muons__StarterKit.obj");
root [4] Events->Scan("muons.pt()"); 
*    Row   * Instance * muons.pt( *
*        0 *        0 * 44.260364 *
*        0 *        1 * 39.531116 *
*        1 *        0 * 29.103748 *
*        1 *        1 * 26.258148 *
*        2 *        0 * 19.219930 *
*        2 *        1 * 18.588388 *
*        3 *        0 * 28.487718 *
*        3 *        1 * 5.5462031 *
*        4 *        0 * 32.164604 *
*        5 *        0 * 42.194877 *
*        6 *        0 * 52.350521 *
*        6 *        1 * 33.541160 *
*        7 *        0 * 21.837554 *
*        7 *        1 * 2.8129720 *
*        8 *        0 * 28.073509 *
*        9 *        0 * 45.597820 *
*        9 *        1 * 43.054576 *
*       10 *        0 * 27.573650 *
*       10 *        1 * 27.094858 *
*       11 *        0 * 32.984851 *
*       11 *        1 * 31.733356 *
*       11 *        2 * 2.4682543 *
*       11 *        3 * 1.6808302 *
*       11 *        4 * 1.1011434 *
*       12 *        0 *           *
Type <CR> to continue or q to quit ==> 

This starts to scan through the objects in the "muon pt" branch. You can also start making more advanced plots in principle, but we'll just plot the muon pt of the first muon. Hit "q" to "quit" the scan over the muon pt, and type

root [5] Events->Draw("muons[0].pt()", "muons[0].pt() < 1000");

You should obtain a plot that looks like this:


Now, you can also make cuts on your ntuple as follows:

root [6] Events->Draw("muons[0].pt()", "muons[0].pt() > 30 && muons[0].pt() < 1000");

This cuts on the muon pt to be greater than 30 GeV/c. You should obtain something that looks like this:


This should give you the flavor of the types of things that can be done with the command line interface. This behaves exactly like a standard ROOT TTree after you have made these alias commands, and you should be able to do whatever you like with the TTree functionality on the command line.

We now turn to using derivatives of TSelectors, the FWLite::Event model.

Using FWLite::Event

To do any sort of "meaningfully complicated" analysis, it will be necessary to use a macro instead of a command line argument. To do so, Chris Jones and others have developed utilities to do this, which you can read about here:


The StarterKit is (in principle) fully compatible with FWLite but at the moment we have not yet implemented a test suite for those tools. However there are easily available tools for running on the "ntuple" output of the StarterKit which can be derived simply from the above link.

For the following example, be sure that you use the attached rootlogon.C file. This will set up the environment. Then, you can open the file sk_fwlite.C, and edit it to point to the proper skim file (/my_scratch/username/PatAnalyzerSkeletonSkim.root).

The file is here:


In its entirety, it is here:

#include "DataFormats/FWLite/interface/Handle.h"
#include "DataFormats/FWLite/interface/Event.h"
#include "TFile.h"
#include "TH1.h"
#include "TCanvas.h"
#include "TLegend.h"

#if !defined(__CINT__) && !defined(__MAKECINT__)
#include "DataFormats/PatCandidates/interface/Muon.h"

#include <iostream>

using namespace std;

void sk_fwlite()
  TFile  * file = new TFile("PatAnalyzerSkeletonSkim.root");

  using namespace std;

  TH1D * hist_muPt = new TH1D("hist_muPt", "Muon p_{T}", 20, 0, 100 );

  fwlite::Event ev(file);
  for( ev.toBegin();
          ! ev.atEnd();
          ++ev) {
    fwlite::Handle<std::vector<pat::Muon> > h_mu;
    h_mu   .getByLabel(ev,"selectedLayer1Muons");
     for ( int i = 0; i < h_mu.ptr()->size();  ++i ) {
       vector<pat::Muon> const & muons = *h_mu;
       hist_muPt->Fill( muons[i].pt() );

Then, you can type

root -l PatAnalyzerSkeletonSkim.root

root[1] .L sk_fwlite.C++
root[2] sk_fwlite();

To run our example. You should obtain a plot that looks like this:


You can extend this file to do whatever analysis you'd like.

SOME USEFUL TIPS ( though random)

Another fwlite macro showing how to plot Pt of Jet, Electrons, Taus, Photon, Track and MET is here: sk_fwlite_JetMuonPhotonMETTrack.C

The output of root plot looks like this (enable gStyle->SetOptStat(111111) on root prompt) OutputOf_sk_fwlite_JetMuonPhotonMETTrack.png

Another script to plot Muon Pt,Eta and Phi is here: sk_fwlite_MuonPtPxPyPzEtaPhi.C The plots of Muon Pt, Eta and Phi are here Muon_Pt_Phi_Eta.png Plots of Muon Pt computed from Px, Py and Pz (see the macro for the formula) and also Px,Py,Pz are here Muon_PtFromPxPyPz_and-Px_Py_Pz.png. Compare this Pt to Pt above. They should be identical and this is the case.

If one wants to put cuts on, for example on pT, Eta, No. of muons in an event, one can put the following kind of snippet in the python script(PatAnalyzerSkeleton_cfg.py or PatAnalyzerKitDemo_cfg.py)and have only such muons written to your skim file

# input pat sequences

process.selectedLayer1Muons.cut =  cms.string('pt > 30. & abs(eta) < 2.1')
process.minLayer1Muons.minNumber =cms.uint32(5)
process.maxLayer1Muons.maxNumber =cms.uint32(5)

The default file having muon pT,eta selction cuts is at here: http://cmslxr.fnal.gov/lxr/source/PhysicsTools/PatAlgos/python/selectionLayer1/muonSelector_cfi.py The default files for other objects like Jets, taus, Photons are here: http://cmslxr.fnal.gov/lxr/source/PhysicsTools/PatAlgos/python/selectionLayer1/

The plot with muon with no pT cut (i.e. pT>0 GeV) and with pT>30 GeV are below MuonWith_pT_greater_than0GeV MuonWith_pT_greater_than30GeV

Cosmics example with FWLite

It is possible to run cosmics data with PAT and FWLite as well. We provide an example configuration here.

We also provide a modified FWLite macro to make a simple muon eta-vs-phi plot here.

It can be run as follows:

cmsRun cosmics_cfg.py

root -l
root[1] .L sk_fwlite_cosmics.C++
root[2] sk_fwlite_cosmics();

This will produce a plot that looks like this:



Now we examine the output of the CompositeKitDemo. To run it, do

cmsRun CompositeKitDemo_cfg.py 

If you open the root file CompositeKitHistos.root, open a TBrowser and drill down, you'll see a screen that looks like this:


You'll notice that in addition to the physics object directories, there is a directory called "hToZZ". Clicking on this yields


If you click on "hToZZMass_1" you get


This is the invariant mass of all the candidates in question.

You can also look at the invariant masses of the constituents, for instance you can click on the folder called "Z1" to see:


Clicking on the mass, you see


Now you can click on the constituents of the Z's, for instance "muon1" to see:


You have access to all the histograms for all the constituents. This is helpful in making sideband subtraction plots, for instance, since you can plot the histogram for the objects under the Z peak, and those outside.

For instance, clicking on "muon1Pt_1", you obtain


Common Errors

Here we discuss some common errors from users.

scram project errors

If you see something like

Can't locate XML/Parser/Expat.pm in @INC (@INC contains: /uscmst1/prod/sw/cms/slc4_ia32_gcc345/lcg/SCRAMV1/V1_0_3-p2 /uscmst1/prod/sw/cms/slc4_ia32_gcc345/lcg/SCRAMV1/V1_0_3-p2/src /uscmst1/prod/sw/cms/slc4_ia32_gcc345/lcg/SCRAMV1/V1_0_3-p2 /uscmst1/prod/sw/cms/slc4_ia32_gcc345/external/p5-libwww-perl/1.41-CMS19/lib/site_perl/5.8.5 /uscmst1/prod/sw/cms/slc4_ia32_gcc345/external/p5-xml-parser/2.34-CMS19/lib/site_perl/5.8.5 /uscmst1/prod/sw/cms/slc4_ia32_gcc345/external/p5-uri/1.35-CMS19/lib/site_perl/5.8.5 /uscmst1/prod/sw/cms/slc4_ia32_gcc345/external/p5-template-toolkit/2.15-CMS19/lib/site_perl/5.8.5 /uscmst1/prod/sw/cms/slc4_ia32_gcc345/external/p5-template-toolkit/2.15-CMS3/lib/site_perl/5.8.5 /opt/gLite/lcg/lib/perl /opt/gLite/external/usr/lib/perl5/vendor_perl/5.8.5 /opt/rocks/lib/perl5/5.8.8/x86_64-linux /opt/rocks/lib/perl5/5.8.8 /opt/rocks/lib/perl5/site_perl/5.8.8/x86_64-linux /opt/rocks/lib/perl5/site_perl/5.8.8 /opt/rocks/lib/perl5/site_perl .) at /uscmst1/prod/sw/cms/slc4_ia32_gcc345/lcg/SCRAMV1/V1_0_3-p2/src/ActiveDoc/SimpleXMLDoc.pm line 33.
BEGIN failed--compilation aborted at /uscmst1/prod/sw/cms/slc4_ia32_gcc345/lcg/SCRAMV1/V1_0_3-p2/src/ActiveDoc/SimpleXMLDoc.pm line 33.
Compilation failed in require at /uscmst1/prod/sw/cms/slc4_ia32_gcc345/lcg/SCRAMV1/V1_0_3-p2/src/BuildSystem/XMLBuildFile.pm line 17.
BEGIN failed--compilation aborted at /uscmst1/prod/sw/cms/slc4_ia32_gcc345/lcg/SCRAMV1/V1_0_3-p2/src/BuildSystem/XMLBuildFile.pm line 17.
Compilation failed in require at /uscmst1/prod/sw/cms/slc4_ia32_gcc345/lcg/SCRAMV1/V1_0_3-p2/src/BuildSystem/BuildDataStorage.pm line 195.
BEGIN failed--compilation aborted at /uscmst1/prod/sw/cms/slc4_ia32_gcc345/lcg/SCRAMV1/V1_0_3-p2/src/BuildSystem/BuildDataStorage.pm line 195.
Compilation failed in require at /uscmst1/prod/sw/cms/slc4_ia32_gcc345/lcg/SCRAMV1/V1_0_3-p2/src/SCRAM/CMD.pm line 1005.
BEGIN failed--compilation aborted at /uscmst1/prod/sw/cms/slc4_ia32_gcc345/lcg/SCRAMV1/V1_0_3-p2/src/SCRAM/CMD.pm line 1005.
Compilation failed in require at /uscmst1/prod/sw/cms/slc4_ia32_gcc345/lcg/SCRAMV1/V1_0_3-p2/src/SCRAM/SCRAM.pm line 40.
BEGIN failed--compilation aborted at /uscmst1/prod/sw/cms/slc4_ia32_gcc345/lcg/SCRAMV1/V1_0_3-p2/src/SCRAM/SCRAM.pm line 40.
Compilation failed in require at /uscmst1/prod/sw/cms/slc4_ia32_gcc345/lcg/SCRAMV1/V1_0_3-p2/bin/scramv1 line 444.
BEGIN failed--compilation aborted at /uscmst1/prod/sw/cms/slc4_ia32_gcc345/lcg/SCRAMV1/V1_0_3-p2/bin/scramv1 line 444.

Thanks to Patrick Gartung and Catalin Dumitrescu, we have a solution for this.

Ensure that the following lines are not in your .cshrc file:

if ( -f "/afs/fnal.gov/ups/etc/setups.csh" ) then
 source "/afs/fnal.gov/ups/etc/setups.csh"

if ( { ups exist shrc } ) then
 setup shrc


We have developed a questionnaire for you to fill out to help us help you! Please copy and paste the following into an email to the authors above when you are finished with the Requests, and give us your feedback. This is text-only, so be patient with us!

These are exclusive categories, so please select the one that most describes you:

1) How familiar are you with C++ 

[ ] a) I could code a std::map<std::string,std::vector<int> > and have no problem.
[ ] b) I know what public inheritance means but I can't figure out what you're talking
         about in (a).
[ ] c) I'm still mad we went away from F77.

2) How familiar are you with ROOT?

[ ] a) I've successfully added my own classes to ROOT.
[ ] b) I can book my own histograms and plot them without trouble.
[ ] c) I still use PAW.

3) Have you performed CMSSW analyses before?

[ ] a) Yes, and I probably could actually have written this better than you. 
[ ] b) Yes, but not at the expert level.
[ ] c) Are you kidding? You're supposed to be doing this for me!

4) Have you used FWLite?

[ ] a) Yes, I've used it and I love it!
[ ] b) Yes, I've used it but it needs some work.
[ ] c) No. 

5) How long did it take you to get from cvs checkout procedure to a plot?

[ ] a) Less than an hour.
[ ] b) Between an hour and a day.
[ ] c) More than a day.

6) What analysis are you planning on doing in CMS? 


7) Did you like this type of framework?

[ ] a) This will be great when you get it working. Suggestions below.
[ ] b) This is too complicated, make it simpler. Suggestions below.
[ ] c) I thought it was awful and didn't accomplish any of the goals I needed it to do.
         Suggestions below.


8) Any further comments or questions:


Starter Kit To-Do List

As you can see, we have a fairly functional Starter Kit to start you off with. The last pieces are coming together in the coming weeks. They include

  • Generic histogramming utilities. These will include the following capabilities:
    • Config file booking of simple and more complex variables (pt(jet1) / pt(jet2), for instance).
    • More user control over histogram binning and axis limits.
    • "Before and after" plots given some cuts.
  • Automated nightly validation scripts for monitoring purposes.

Review status

Reviewer/Editor and Date Comments
Main.Aresh - 21 Feb 2008 changes in verbatim elements because of some lines too long for printable version
SalvatoreRappoccio - 03 Dec 2007 page author

%RESPONSIBLE% Salvatore Rappoccio and Sudhir Malik
%REVIEW% Sudhir Malik- 5 November 2008.

Topic attachments
I Attachment History Action Size Date Who Comment
Cascading Style Sheet filecss tutorial.css r1 manage 0.3 K 2009-01-09 - 17:09 SudhirMalik  
Edit | Attach | Watch | Print version | History: r3 < r2 < r1 | Backlinks | Raw View | WYSIWYG | More topic actions
Topic revision: r3 - 2009-01-09 - SudhirMalik
    • Cern Search Icon Cern Search
    • TWiki Search Icon TWiki Search
    • Google Search Icon Google Search

    Sandbox All webs login

This site is powered by the TWiki collaboration platform Powered by PerlCopyright & 2008-2023 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