Appendices (Including Glossary)

A.1 Specific Information for Remote Sites and Institutions

Complete:
Detailed Review status

Contents

Goals of this page:

This page is intended to provide links to CMS-affiliated, non-CERN, site-specific and institution-specific information that is essential for users working from these institutions to complete the tutorials and exercises in the workbook.

Introduction

Site administrators and/or system administrators are encouraged to provide any necessary information that deviates from the workbook instructions such that a CMS user working from your site/institution can accomplish all the tasks in the workbook. If the information is brief, you may include it directly in the current page. Otherwise, please provide links on this page pointing to the information. The information may reside on web pages that you maintain elsewhere, or you may create new workbook pages from this page. For the latter, see the twiki formatting help (available from any editing screen) and WorkBookContributors.

Examples include but are not limited to:

• how to get computing privileges and accounts at the site/institution,
• login information to local clusters that maintain the CMS environment,
• information about grid resources (besides LCG) that are available, and so on.

#CERN

CERN

There are various facilities provided at CERN for CMS usage. Please see the facility page to see if it is available to you. To interact with CERN storage systems a set of tools is available.

• CERN Analysis Facility - High priority workflows
• T2_CH_CERN - Tier-2 for CERN based users
• CERN CMS Tier-3 - Tier-3 for CERN employees

U.S. Tier-1 site affiliates

U.S. CMS is a collaboration of US scientists participating in the CMS experiment. The CMS T1 site in the U.S. is at Fermilab (also known as FNAL), which houses the LHC Physics Center (http://www.uscms.org/uscms_at_work/physics/lpc/index.shtml), a location for CMS physicists to find experts on all aspects of data analysis, particle ID, software, and event processing within the US, during hours convenient for U.S.-based physicists.

Find USCMS-specific software and computing information at User Computing (http://www.uscms.org/uscms_at_work/physics/computing/index.shtml). We collect some of the information from the USCMS web site here for convenience.

#CMS.FermiLab

Fermilab

Getting a Fermilab Account

You must be registered with Fermilab before you can get any accounts. NOTE: This can take 4-6 weeks to process for both new and yearly renewals, and be sure to follow instructions emailed to you. The following web page: How to get a CMS Computing Account at Fermilab (http://www.uscms.org/uscms_at_work/computing/getstarted/getaccount_fermilab.shtml), outlines all necessary steps to get a CMS specific account at Fermilab together with Fermilab registration and points you to the online forms that have to be filled out. Please comment to request the same account name at both CERN and Fermilab.

Login to CMSLPC

The most up to date instructions on how to get access to cmslpc-sl7 cluster and how to configure your /etc/krb5.conf and ~/.ssh/config are given at How to get access to the (CMSLPC) cluster (http://www.uscms.org/uscms_at_work/data_computing/facility_operations/uaf.shtml).

You can get the CMSSW environment with the following command (tcsh shell) every time you login (or add to your ~/.tcshrc or ~.bash_profile to be done automatically upon login):

source /cvmfs/cms.cern.ch/cmsset_default.csh

source /cvmfs/cms.cern.ch/cmsset_default.sh

And then you can Setup your CMSSW environment as you would elsewhere:

Only if not setup previously, make a new CMSSW

cmsrel CMSSW_11_0_1

cd CMSSW_11_0_1/src
cmsenv

Mass Storage

Users generally have an LPC FNAL EOS area automatically made with their account (eosls /store/YourUsername), but it is not automatically linked to your personal grid certificate, and therefore not usable with CRAB by default. You will need to follow the instructions to [[https://uscms.org/uscms_at_work/computing/LPC/usingEOSAtLPC.shtml#createEOSArea][Get your EOS area linked to your CERN username]], note that this step takes up to 1 business day to take effect.

Grid computing

The US CMS Grid is part of the worldwide LHC Computing Grid for LHC science analysis. The US CMS grid environment is part of the Open Science Grid (OSG) infrastructure. The instructions on page Starting on the GRID are valid for Fermilab users.

For information on grid certificates, Fermilab users should obtain CERN CA personal certificates CERN CA personal certificates (https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideLcgAccess).

CRAB

Like other sites, you have to set up the Grid UI, your CMSSW release, and then CRAB but the commands are slightly different. They are listed here.

CRAB, as set up at FNAL, has a couple of extra features that you may find useful. FNAL users can have their jobs run exclusively on the LPC tier3, which may in some cases allow their jobs to start faster. The pool of users who are requesting time on the tier3 might be smaller than the group of people in the global pool. Also, LPC users are the only ones allowed to have CRAB jobs run on T3_US_FNALLPC. Only a couple of modifications need to be made to the users CRAB configuration file for the jobs to be run here.

config.Data.ignoreLocality = True
config.Site.whitelist = ['T3_US_FNALLPC']
config.Site.ignoreGlobalBlacklist = True

More information about this can be found at the CRAB3HATS2016 twiki page twiki and the Indico page for the same event.

Batch system

The batch system available for users of the CMSLPC cluster is condor which allows the user to submit jobs into the production farm. The use of this batch system is described on the following page: Batch System (http://uscms.org/SoftwareComputing/UserComputing/BatchSystem.html) Note that you will need to have Fermilab link your personal grid certificate in the CMS VO to your Fermilab account to use this batch system, to do that follow instructions here: link your grid certificate to Fermilab account: for both FNAL EOS and condor batch It is recommended that if you are submitting cmsRun jobs, you use the CRAB mechanism described above as this does everything correctly for you already. It is much easier, both for users and for the support group.

Getting help at Fermilab

Go to http://lpc.fnal.gov/computing/gethelp.shtml to find out how to get help with computing at the LPC CAF at Fermilab, in particular you can open a LPC Service Portal ticket.

Germany Tier-1 site affiliates

This information is included from original FSP-CMS Analysys Support page. No permission to view CMS.GermanUsersComputingSupport

DESY Hamburg

Information about local computing resources at DESY Hamburg can be found in LocalComputingIssuesHamburg.

Italy Tier-1 site affiliates

UK Tier-1 site affiliates

Imperial College London

Complete information for users willing to work from Imperial College London can be found in ImperialCollegeLondonWorkBook.

Login platforms at OSG Tier-2s

Some of the OSG Tier-2s provide a login platform for their "local users". To get access to this login platform you should email the site contact listed in CMS.SiteDB.

CVMFS should be available on all of the OSG sites. To get started, you generally need to first setup your environment by doing one of the following:
source $OSG_APP/cmssoft/cms/cmsset_default.csh
source $OSG_APP/cmssoft/cms/cmsset_default.sh
depending on what shell you are working in.

Review status

Responsible: SudhirMalik
Last reviewed by: SudhirMalik - 26 Nov 2008 (FNAL)

A.2 Troubleshooting Guide: Understanding and Solving Common Software Issues

Programming and especially using CMSSW is a complicated thing. And even though the quest of common tools such as Physics Analysis Toolkit (PAT) is to simplify things they are still far from trivial to use it. When you start using PAT, CMSSW or just start programming there is a bunch of problems you will always encounter. During a normal evolution process you start with parse and linking errors during compile time and via the mysteries of python errors finally arrive at CMSSW complaints during runtime. Gaining the experience to recognize these errors is an important but painful process. This page should give you some assistance to cope with very typical errors that always occur when beginners get started.

Note: By construction this page is evolving with time. We will try to add more and more typical errors with increasing experience.

Compiler Errors

In modern software architectures not all source code, that is used is compiled into a single very heavy executable. It is rather split into a set of clearly structured pre-compiled shared library object files ( .so). These shared library object files will be loaded dynamically when really needed during the compilation of the actual executable. Consequently the compilation of a new cmsRun executable consists of two parts:

• Parsing:
  The grammar of the source code you wrote is checked for its correctness. The compiler checks that you did not forget any key signs (like '#', or ';'), that all functions and their arguments are known and understood and their return values match to the expected types. The declaration of new functions can be found in the header files ( .h) files that were added in the implementation of the source code.

• Linking:
  Some functions that were used in the source code might be implemented in different pre-compiled shared library objects ( .so). In this step all .so files needed for the compilation of the executable are searched and linked.

Error: expected `;' before...

For the error below we commented a ';' from line 104 of the PatBasicAnalyzer.cc source file of the PatExamples package:

...
>> Entering Package PhysicsTools/PatExamples

>> Compiling /afs/cern.ch/user/r/rwolf/scratch0/CMSSW_3_8_X_2010-09-12-1300/src/CMS.PhysicsTools/PatExamples/plugins/PatBasicAnalyzer.cc 

/afs/cern.ch/user/r/rwolf/scratch0/CMSSW_3_8_X_2010-09-12-1300/src/CMS.PhysicsTools/PatExamples/plugins/PatBasicAnalyzer.cc: In member function 'virtual void PatBasicAnalyzer::analyze(const edm::Event&, const edm::EventSetup&)':
/afs/cern.ch/user/r/rwolf/scratch0/CMSSW_3_8_X_2010-09-12-1300/src/CMS.PhysicsTools/PatExamples/plugins/PatBasicAnalyzer.cc:107: error: expected `;' before 'histContainer_'
...

Note: This is a simple error. The compiler explains you exactly what going in. The error occurs for line 107 (and not in line 104, which was modified by us) as there the next statement starts.

• What's going on?
  The compiler found a statement that was not finished by a ';'.

• What happened?
  You added a few lines of code to your module and forgot the ';' at the end of the input line.

• What is the remedy?
  Add the ';' at the end of the indicated line.

histContainer_["jets"]->Fill(nJets); 

Error: expected `}' at end of input...

For the error below we commented a '}' from line 103 of the PatBasicAnalyzer.cc source file of the PatExamples package:

...
>> Compiling /afs/cern.ch/user/r/rwolf/scratch0/CMSSW_3_8_X_2010-09-12-1300/src/CMS.PhysicsTools/PatExamples/plugins/PatBasicAnalyzer.cc 

/afs/cern.ch/user/r/rwolf/scratch0/CMSSW_3_8_X_2010-09-12-1300/src/CMS.PhysicsTools/PatExamples/plugins/PatBasicAnalyzer.cc: In member function 'virtual void PatBasicAnalyzer::analyze(const edm::Event&, const edm::EventSetup&)':
/afs/cern.ch/user/r/rwolf/scratch0/CMSSW_3_8_X_2010-09-12-1300/src/CMS.PhysicsTools/PatExamples/plugins/PatBasicAnalyzer.cc:116: error: a function-definition is not allowed here before '{' token
/afs/cern.ch/user/r/rwolf/scratch0/CMSSW_3_8_X_2010-09-12-1300/src/CMS.PhysicsTools/PatExamples/plugins/PatBasicAnalyzer.cc:133: error: a function-definition is not allowed here before '{' token
...
afs/cern.ch/cms/slc5_ia32_gcc434/external/gcc/4.3.4/bin/../lib/gcc/i686-pc-linux-gnu/4.3.4/../../../../include/c++/4.3.4/bits/locale_facets_nonio.h:46: error: expected `;' before '__attribute__'
/afs/cern.ch/user/r/rwolf/scratch0/CMSSW_3_8_X_2010-09-12-1300/src/CMS.PhysicsTools/PatExamples/plugins/PatBasicAnalyzer.cc:137: error: expected `}' at end of input
gmake: *** [tmp/slc5_ia32_gcc434/src/PhysicsTools/PatExamples/plugins/PhysicsToolsPatExamples_plugins/PatBasicAnalyzer.o] Error 1
...

Note: This error can be tricky as during the parsing a lost opening '{' or closing '}' brace may still lead to code that might be syntactically correct, but in the first places changes its meaning. Only after a few lines the grammar parsing fails and leads to this error. In our case of a missing '}' latest at the end a characteristic error occurred.

• What's going on?
  The compiler found a missing '}', the following lines mit grammatically still be OK or lead to first parse errors. Latest at the end of the file the missing '}' beomes apparent.

• What happened?
  You got mixed up with opening and closing braces. At the end you forgot one of them.

• What is the remedy?
  This error is nasty as it is not always clear where it appears. The easiest way is to follow the indentation of your editor and in hard cases to comment and uncomment parts of the code step by step.

Error: 'XXX' is not a member of 'yyy'...

For the error below we commented the .h file for the declaration of pat::Muons from the PatBasicAnalyzer.cc in the PatExamples package:

...
>> Entering Package PhysicsTools/PatExamples

>> Compiling /afs/cern.ch/user/r/rwolf/scratch0/CMSSW_3_8_X_2010-09-12-1300/src/CMS.PhysicsTools/PatExamples/plugins/PatBasicAnalyzer.cc 

/afs/cern.ch/user/r/rwolf/scratch0/CMSSW_3_8_X_2010-09-12-1300/src/CMS.PhysicsTools/PatExamples/plugins/PatBasicAnalyzer.cc: In member function 'virtual void PatBasicAnalyzer::analyze(const edm::Event&, const edm::EventSetup&)':
/afs/cern.ch/user/r/rwolf/scratch0/CMSSW_3_8_X_2010-09-12-1300/src/CMS.PhysicsTools/PatExamples/plugins/PatBasicAnalyzer.cc:75: error: 'Muon' is not a member of 'pat'
...

Note: This error equally holds for any other objects that you might have introduced in your code without declaring them to the compiler: reco::Muons, edm::InputTags or pat::Jets, ...

• What's going on?
  The compiler found an object that has never been declared when parsing your source file. In our example this is the pat::Muon.

• What happened?
  You added an object to your code which is not known a priori to the compiler. You have to make the declaration known in a .h file.

• What is the remedy?
  Add the corresponding .h file that contains the declaration of the object you defined in your source code.

#include "DataFormats/PatCandidates/interface/Muon.h" 

Error: undefined reference

All .so files needed to compile the executable are defined in the CMS.BuildFile of your package or corresponding subdirectories. The complete name of each corresponding .so file inherits from the name of the package and the subsystem the referred function is declared and implemented in. If you add the corresponding .so file of this package the error should be gone.

Some plugins in the PatExamples package make use of function that have been defined in the PatExamples package itself. For the error given below we commented the .so file of the PatExamples package from the CMS.BuildFile located in the plugins directory of the PatExamples package:

...
tmp/slc5_ia32_gcc434/src/PhysicsTools/PatExamples/plugins/PhysicsToolsPatExamples_plugins/libPhysicsToolsPatExamples_plugins.so: undefined reference to `PatBTagCommonHistos::~PatBTagCommonHistos()'
tmp/slc5_ia32_gcc434/src/PhysicsTools/PatExamples/plugins/PhysicsToolsPatExamples_plugins/libPhysicsToolsPatExamples_plugins.so: undefined reference to `PatBTagCommonHistos::Set(std::basic_string<char>, std::allocator >)'
tmp/slc5_ia32_gcc434/src/PhysicsTools/PatExamples/plugins/PhysicsToolsPatExamples_plugins/libPhysicsToolsPatExamples_plugins.so: undefined reference to `PatBTagCommonHistos::PatBTagCommonHistos(edm::ParameterSet const&)'
tmp/slc5_ia32_gcc434/src/PhysicsTools/PatExamples/plugins/PhysicsToolsPatExamples_plugins/libPhysicsToolsPatExamples_plugins.so: undefined reference to `PatBTagCommonHistos::Fill(boost::indirect_iterator<__gnu_cxx::__normal_iterator<pat::Jet const* const*, std::vector<pat::Jet const*, std::allocator<pat::Jet const*> > >, boost::use_default, boost::use_default, boost::use_default, boost::use_default>&, std::basic_string<char>, std::allocator >)'
tmp/slc5_ia32_gcc434/src/PhysicsTools/PatExamples/plugins/PhysicsToolsPatExamples_plugins/libPhysicsToolsPatExamples_plugins.so: undefined reference to `PatBTagCommonHistos::Sumw2()'
collect2: ld returned 1 exit status
gmake: *** [tmp/slc5_ia32_gcc434/src/PhysicsTools/PatExamples/plugins/PhysicsToolsPatExamples_plugins/libPhysicsToolsPatExamples_plugins.so] Error 1
...

Note: This is a rare error, unless you start a project from scratch the BuildFiles you are using are pretty complete.

• What's going on?
  The linker does not find the implementation of a function that you use in your code.

• What happened?
  You used a function somewhere in your code and added the .h file where the declaration of the function can be found. You forgot to make the .so file known to the compiler in which the implementation (located in the .cc file in the corresponding package) is defined.

• What is the remedy?
  Add the corresponding .so file in the CMS.BuildFile of your package. A safe way is to check for all packages that you used in your source code to declare your objects from the start on.

<use   name="CMS.PhysicsTools/PatExamples"/> 

Python Errors

The common configuration language for cmsRun is python. Have a look at WorkBookConfigFileIntro to learn more about the structure of cmsRun configuration files. Have a look at this tutorial to learn more about python itself. Before starting cmsRun we recommend you to parse your configuration file for its syntactical correctness using the python interpreter. The way to do this is shown below for the examples of a typical configuration file in the PatExamples package:

python PhysticsTools/PatExamples/test/patTuple_standard_cfg.py

A set of typical python errors is given below:

Error: 'Process' object has no attribute 'XXX'

Traceback (most recent call last):
  File "CMS.PhysicsTools/PatExamples/test/analyzeTopSelection_cfg.py", line 137, in 
    process.step7      *
AttributeError: 'Process' object has no attribute 'step7'

Note: For this error we introduced a typo in line 67 to the analyzeTopSelection_cfg.py configuration file of the more complex analysis example in the PatExamples package.

• What's going on?
  At least one module is not know to the python interpreter when checking the process path of the configuration file.

• What happened?
  Most probably you introduced a typo in the definition of your modules or in the process path or you introduced a module in the path that you forgot to define before. Note that module definitions might also be hidden in imported file.

• What is the remedy?
  The best cure might be to check all module definitions for their consistency. The linux tool grep might be of help for you.

process.step7 = countPatJets.clone(src = 'goodJets' , minNumber = 4) 

Error: No module named XXX

Traceback (most recent call last):
  File "CMS.PhysicsTools/PatExamples/test/analyzeTopSelection_cfg.py", line 35, in 
    process.load("CMS.PhysicsTools.PatExamples.topObjectSelection")
  File "/afs/naf.desy.de/group/cms/sw/slc5_ia32_gcc434/cms/cmssw/CMSSW_3_8_2/python/FWCore/ParameterSet/Config.py", line 409, in load
    module = __import__(moduleName)
ImportError: No module named topObjectSelection

Note: For this error we introduced a typo in line 35 to the analyzeTopSelection_cfg.py configuration file of the more complex analysis example in the PatExamples package. We omitted the "_cff" in the load command.

• What's going on?
  There is a file specified an import or load statement that does not exist.

• What happened?
  Either you introduced a file vie import or load that does not exist, or you introduced a typo in the file name or path.

• What is the remedy?
  Check the path and name of the corresponding file in your working directory. Note that python directories are always omitted in the configuration file.

process.load("CMS.PhysicsTools.PatExamples.topObjectSelection:cff") 

Error: XXX does not already exist

Traceback (most recent call last):
  File "CMS.PhysicsTools/PatExamples/test/analyzeTopSelection_cfg.py", line 67, in 
    process.step7  = countPatJets.clone(src2 = 'goodJets'   , minNumber = 4)
  File "/afs/naf.desy.de/group/cms/sw/slc5_ia32_gcc434/cms/cmssw/CMSSW_3_8_2/python/FWCore/ParameterSet/Mixins.py", line 297, in clone
    self._Parameterizable__raiseBadSetAttr(key)
  File "/afs/naf.desy.de/group/cms/sw/slc5_ia32_gcc434/cms/cmssw/CMSSW_3_8_2/python/FWCore/ParameterSet/Mixins.py", line 221, in __raiseBadSetAttr
    raise TypeError(name+" does not already exist, so it can only be set to a CMS python configuration type")
TypeError: src2 does not already exist, so it can only be set to a CMS python configuration type

Note: Again for this error we introduced a typo in line 67 to the analyzeTopSelection_cfg.py configuration file of the more complex analysis example in the PatExamples package.

• What's going on?
  At least one parameter of which you wanted replace a value does not exist in the definition of the module.

• What happened?
  Either you introduced a typo, when specifying the parameter name or you really try to replace a parameter that does not exist. in rare cxases it happens that the module definition indeed changed under the hood from release to release.

• What is the remedy?
  Check with the original definition of the module in the corresponding cfi file.

process.step7 = countPatJets.clone(src = 'goodJets' , minNumber = 4) 

Error: more than 255 arguments

...
Problem with configuration file analyser_cfg.py ---- Configuration BEGIN
python encountered the error:  more than
255 arguments (analyser_cfg.py, line 11) ---- Configuration END
...

Note: This is a typical error that occurs if you have more than 255 input files for your source module.

• What's going on?
  The python interpreter encountered a vector with more than 255 input arguments.

• What happened?
  You introduced a vector or list in your python configuration file which has more than 255 arguments.

• What is the remedy?
  this is aknown short coming of python. You can circumvent it though following some tricks as indicated on SWGuidePythonTips#Running_on_more_than_255_files.

Runtime Errors

Runtime errors only occur when you execute cmsRun. In the following we are dealing with errors that occur in the use of cmsRun and in the interplay of different module in the communication among each other or with the event content. These are errors that can not by traced by syntactical checks of the compiler or python interpreter. we summarise a few very typical errors and their remedy below:

Error: Failed to open the file

%MSG-s CMSException:  AfterFile 15-Sep-2010 13:06:41 CEST pre-events
cms::Exception caught in cmsRun
---- FileOpenError BEGIN
---- StorageFactory::open() BEGIN
Failed to open the file 'wjets/patTuple_0_wjets10_madAODs.root' because:
---- File::sysopen() BEGIN
open() failed with system error 'No such file or directory' (error code 2)
---- File::sysopen() END
---- StorageFactory::open() END
 

RootInputFileSequence::initFile(): Input file file:wjets/patTuple_0_wjets10_madAODs.root was not found or could not be opened.


Error occurred while creating source PoolSource
---- FileOpenError END
%MSG

Note: For this error we specified an input file which does not exist.

• What's going on?
  The cmsRun executable cannot open the specified input file.

• What happened?
  Either the input file you specified does not exist, or you introduced a typo. Also take care that cmsRun needs the keyword file: to specify that the given file is to be specified locally.

• What is the remedy?
  Check the file name and file location.

process.source = cms.Source("PoolSource", fileNames = cms.untracked.vstring( 'file:wjets/patTuple_0_wjets10_madAOD.root' ) ) 

Error: Unable to find plugin 'XXX'

%MSG-s CMSException:  AfterModConstruction 15-Sep-2010 13:30:37 CEST pre-events
cms::Exception caught in cmsRun
---- PluginNotFound BEGIN
Unable to find plugin 'PatTopSelectionAnalyser'. Please check spelling of name.
---- PluginNotFound END
%MSG

Note: For this error we introduced a typo in the module definition of the PatTopSelectionAnalyzer_cfi.py file of the more complex analysis example in the PatExamples package. We replaced the 'z' by an 's' in the first argument, which specifies the corresponding plugin "PatTopSelectionAnalyzer".

• What's going on?
  In the configuration file a module is called for which no plugin exists.

• What happened?
  Either you introduced a module in your configuration which really has no correspondence in the list of plugins (this can happen if you forgot to compile the package you are working with) or you introduced a typo what specifying it.

• What is the remedy?
  Check the plugin name you were really out for. The first step would be to grep in what module definition the plugin is specified. Next you can check whether this module really has no correspondence in the list of plugins (in our example typing edmPluginDump | grep PatTopSelectionAnalyser would do the trick). Finally you can check the correctness when looking into the plugin registry step (in our example indicated in the last line of PatTopSelectionAnalyzer.cc)

grep -r PatTopSelectionAnalyser PhysicsTools/PatExamples
CMS.PhysicsTools/PatExamples/python/PatTopSelectionAnalyzer_cfi.py:analyzePatTopSelection = cms.EDAnalyzer("PatTopSelectionAnalyser",
Binary file PhysicsTools/PatExamples/python/PatTopSelectionAnalyzer_cfi.pyc matches
edmPluginDump | grep PatTopSelectionAnalyser
emacs PhysicsTools/PatExamples/plugins/PatTopSelectionAnalyzer.cc

Error: No "JetCorrectionsRecord" record found in the EventSetup

cms::Exception caught in cmsRun
---- EventProcessorFailure BEGIN
EventProcessingStopped
---- ScheduleExecutionFailure BEGIN
ProcessingStopped
---- NoRecord BEGIN
No "JetCorrectionsRecord" record found in the EventSetup.
 Please add an ESSource or ESProducer that delivers such a record.

Note: This error can occur in two ways. The most direct way is indeed that you want to make use of a jet energy corrections service in you code, but did not not specify it in the configuration file. In the transition from CMSSW_3_6_X to CMSSW_3_8_X it might also happen that you specified the proper jet energy correction service but did not use the correct CMS.GlobalTag. As a transition of the jet energy correction constants from bare txt files to the conditions data base took place between these two release cycles even when you specified the proper jet energy correction service you will get the same error in this special case.

• What's going on?
  In one of your modules you try to use a jet energy correction service, which is not known to cmsRun.

• What happened?
  Either you added a jet correction service in on of your modules but did not specify it in your configuration file or (in rare cases) you did everything right but do not use the proper CMS.GlobalTag.

• What is the remedy?
  Specify the jet energy correction service in you configuration file or move to the porper CMS.GlobalTag.

## load jet corrections process.load("JetMETCorrections.Configuration.JetCorrectionServicesAllAlgos_cff") process.prefer("ak5CaloL2L3") 

The exact choice of the correction service might depend on the jet collections you are going to use. Please have a look to SWGuideJetMet, or contact the corresponding experts for more details.

Error: Found zero products matching all criteria

cms::Exception caught in cmsRun
---- EventProcessorFailure BEGIN
EventProcessingStopped
---- ScheduleExecutionFailure BEGIN
ProcessingStopped
---- ProductNotFound BEGIN
getByLabel: Found zero products matching all criteria
Looking for sequence of type: reco::Candidate
Looking for module label: goodJet
Looking for productInstanceName: 
cms::Exception going through module PATCandViewCountFilter/step6a run: 1 lumi: 2 event: 1369557
If you wish to continue processing events after a ProductNotFound exception,
add "SkipEvent = cms.untracked.vstring('ProductNotFound')" to the "options" PSet in the configuration.
---- ProductNotFound END
Exception going through path looseEventSelection
---- ScheduleExecutionFailure END
an exception occurred during current event processing
cms::Exception caught in CMS.EventProcessor and rethrown
---- EventProcessorFailure END

Note: For this error we introduced a typo in line 64 to the analyzeTopSelection_cfg.py configuration file of the more complex analysis example in the PatExamples package. We introduced a collection which is not part of the event content and has not been produced before.

• What's going on?
  One of the modules that is scheduled in the process path of your configuration file is looking for a object collection which is not part of the event content.

• What happened?
  Either the object type, module label or instance label of the collection your module is trying to load is not correct or you forgot to produce the corresponding collection beforehand.

• What is the remedy?
  Make sure that the collection your module is trying to load really exists.

[rwolf@tcx061]~/scratch/CMSSW_3_8_2/src% edmDumpEventContent top/patTuple_top_madgraph.root_ttbar10_madAOD.root 
edm::TriggerResults               "TriggerResults"        ""            "HLT8E29."     
edm::TriggerResults               "TriggerResults"        ""            "HLT."         
edm::TriggerResults               "TriggerResults"        ""            "REDIGI."      
edm::TriggerResults               "TriggerResults"        ""            "RECO."        
vector              "offlinePrimaryVertices"    ""            "RECO."        
edm::OwnVector >     "selectedPatJets"       "tagInfos"    "PAT."         
edm::TriggerResults               "TriggerResults"        ""            "PAT."         
vector                 "selectedPatJets"       "caloTowers"    "PAT."         
vector             "selectedPatElectrons"    ""            "PAT."         
vector                  "selectedPatJets"       ""            "PAT."         
vector                  "patMETs"               ""            "PAT."         
vector                 "selectedPatMuons"      ""            "PAT."         
vector              "selectedPatJets"       "genJets"     "PAT."         
vector         "selectedPatJets"       "pfCandidates"    "PAT." 

Alternatively you can define the EventContentAnalyzer module and place it at an arbitrary position in front of the module which causes you trouble:

## check the event content
process.content = cms.EDAnalyzer("EventContentAnalyzer")
process.p = cms.Path( ... process.content * ... ) 

Error: InvalidReference

%MSG-s CMSException:  AfterFile 02-Jun-2010 14:31:43 CEST PostEndRun
cms::Exception caught in cmsRun
---- EventProcessorFailure BEGIN
EventProcessingStopped
---- ScheduleExecutionFailure BEGIN
ProcessingStopped
---- InvalidReference BEGIN
BadRefCore Attempt to dereference a RefCore containing an invalid
ProductID has been detected. Please modify the calling
code to test validity before dereferencing.
cms::Exception going through module PatMCMatching/analyzePatMCMatching run: 1 lumi: 666672 event: 305
---- InvalidReference END
Exception going through path p
---- ScheduleExecutionFailure END
an exception occurred during current event processing
cms::Exception caught in CMS.EventProcessor and rethrown
---- EventProcessorFailure END

Note: In CMSSW composed (or high analysis) objects very often internally refer to the lower level analysis objects they are composed of via pointer relations. A typical example is a reco::Muon pointing to the inner track it was created from. The above problem occurs if you try to dereference such a object pointer to a lower level analysis object which is not part of the event content any more. In our example the reco::Muon would still point to an inner track which has been dropped from the event content at some earlier processing step.

• What's going on?
  There is an object in your analysis code that is referring to another object which is not in the event content any more.

• What happened?
  You try to read out some information via a pointer to a lower analysis object. You did not check whether this pointer still refers to a valid object or not.

• What is the remedy?
  Make sure that each pointer you are calling refers to a valid object via a NULL pointer request. The information you wanted to address does not exist anymore on the input file that you are using.

if(!muon.innerTrack().isNull()){ //now go on if the innerTrack pointer really corresponds to a valid object... } 

Unfortunately the information you wanted to have is most probably lost from the input file you are using. Due to the 'hidden' reference structure of the hogh analysis objects it is non trivial to reduce the file size of an AOD/RECO input file without loosing analysis relevant information. The Physics Analysis Toolkit (PAT) tries to assist you on this quest. Have a look at SWGuidePATEmbeddingExercise to learn more about this.

Useful tools for debugging your code

Useful tools for debugging your code are documented here

Review status

Show Hide

A.3 Basic Linux Commands

Goals of this page:

Contents

• Introduction
• Linux Basics
• Different shells
• Commonly used Linux Commands
• Checking the directory quota
• Environment variables
• Redirection of output
• Running Commands from a File
• Filters
• Editors
• Useful tools
• Links to further documentation
• Information Sources
• Review Status

Introduction

Linux Basics

In Linux the slash (/) is used to separate directories, by contrast with the backslash (\) used in Windows. There are three 'special' directories

• . indicates the current directory
• .. refers to the directory above the current directory (the parent directory)
• ~ is the users 'home' directory - the directory you start in when you login

-rw-r--r-- 1 livio zh 22769 Jan 17 16:26 myfile.txt

permissions are summarized by -rw-r--r-- which is composed by 4 different fields :

  "-"       "rw-"      "r--"      "r--" 

First field "-", specifies if it's a file, a directory or a link. Other fields define the "user", "group" and "others" permissions by a set of 3 characters "rwx" (read, write and execute). In the analyzed example "livio" is the user and "zh" is the goup related to the file. Summarizing the permissions for file "myfile.txt": all the users can read the file but only the user "livio" can modify it.

When working in Linux, you will activate a terminal , and inside the terminal shell will be running, i.e. a program interpreting your commands. Commands are typed inside this shell, and you press ENTER to issue them. For most commands, additional arguments can be issued by using minus signs (where \ signs are used in Windows), e.g. command -a - b -c or command -abc. To find out what options are available for a given command, and what those options do, type command --help, which works in most cases, or try to see more detailed information with the man command.

Filenames can be specified using two types of wildcards:

• a * represents 0 or any combination of characters, e.g. for* can refer to fore, forest, fort, for etc if such files exist,
• a ? represents any signal character, i.e. in this example for? can refer to fore or fort, but not forest. nor for

You need to be very careful when deleting files using wildcards to specify filenames (just rm * removes everything!! rm -i * will ask you interactively)

Different shells

You can switch from one shell to the other just by typing , e.g., /bin/bash, or /bin/tcsh, which can be useful in case a macro or a documentation comes only in one flavour (you may prefer to do bash --login for instance to properly run login scripts). But attention, in some cases this may screw up your environment!

In order to know which shell is the default for you (as decided by the system administrator), type echo $SHELL.

In order to know which shell you are actually using, type echo $0.

Commonly used Linux Commands

Checking the directory quota

Environment variables

Syntax for setting a variable is different for Bourne shells and C shells. To set the environment variable Var to contain the string xyz you will type

• in Bourne Shells

export Var=xyz

• in C Shells

setenv Var xyz

Redirection of output

Redirection to /dev/null will suppress the output.

There are 2 output streams, stdout for normal output, stderr for warnings. Here syntax is different in the 2 shell families:

• in Bourne Shells

command 2> myfile will redirect the stderr of command to myfile

command 1 > myfile 2>&1 will redirect the stdout of command to myfile, and the stderr to the stdout, ie.e to the same file

• in C Shells

command >& myfile will redirect the stderr of command to myfile

command  >& myfile will redirect the stdout and the stderr to myfile

(command >out) >& err will redirect the stdout of command to out, and the stderr to err

You may also redirect output from one command to be input for a second command using a pipe (= |):

ls -l | more

will display the output from ls inside more, i.e. one screen at a time.

Running Commands from a File

The command source myfile (. myfile in C-shells) executes the commands stored in myfile. This would normally be a shell script file.sh or file.csh. You can search the internet for "shell script reference" or a similar string, and find many references to help you get started writing shell scripts.

There are several powerful scripting languages used in Unix, like python or perl.

More information on scripting can be found in the documentation links given below, or by carrying out a basic internet search.

Filters

command | grep txt will show all output lines of command containing the string txt.

command | grep -v txt will show all output lines of command except those containing the string txt.

Editors

• vi

• emacs

• nano

Links to further documentation

• Proficiency with computing tools (includes many tools listed below)
  • https://missing.csail.mit.edu

• Shell Scrips
  • http://www.freeos.com/guides/lsst/
  • http://www.tldp.org/HOWTO/Bash-Prog-Intro-HOWTO.html
• grep
  • http://www.gnu.org/software/grep/
• emacs
  • http://www.gnu.org/software/emacs/manual/html_mono/emacs.html
• vi
  • http://heather.cs.ucdavis.edu/~matloff/UnixAndC/Editors/ViIntro.html
• nano
  • https://www.howtogeek.com/howto/42980/the-beginners-guide-to-nano-the-linux-command-line-text-editor/
• python
  • http://docs.python.org/
  • https://developers.google.com/edu/python/set-up

Information Sources

Review status

Responsible: SudhirMalik
Last reviewed by: UrsulaBerthon - 23 Feb 2008

A.4 ROOT Basics

Complete:

Goals of this workbook page

When you finish this page, you will be able to

• Open and close an interactive ROOT session
• Create and manipulate simple histograms
• Use provided resources to learn how to do further tasks with ROOT

Contents

Introduction

ROOT is an analysis package written in an object-oriented structure in C++. It uses built-in functions and user-compiled code to produce graphics and histograms, as well as trees with data objects. ROOT files can be easily navigated using a GUI Object Browser.

The new CMS event data model (EDM) is based around the idea that people will use ROOT both in a normal "framework application", and by interactive manipulation of tree objects and histograms. The full CMS software structure to use ROOT has an analysis environment is currently under construction, and will become a powerful tool for CMS physics analyses.

Interactive ROOT sessions are conducted using an extension to C++ called CINT. This allows a slightly lazy use of C++, including allowing the use of a dot '.' to access a pointer object rather than the strict C++ arrow '->', and further shortcuts in creating new pointer objects. A help menu of CINT commands can be accessed using '.?'.

Most objects in ROOT can be accessed by familiar names, adding a '_t' as a suffix to data types, and a 'T' prefix to object classes, e.g. Float_t, Double_t, TClass, TFile, ...

The ROOT homepage

The ROOT system homepage is hosted at CERN, and contains many example files, tutorials, How-Tos, FAQs, program downloads and other help. The homepage URL is http://root.cern.ch

Starting a ROOT session

Linux

These instructions enable you to start a ROOT session when logged into a CERN lxplus machine. You will need to contact your local system expert for information on using ROOT on local machines.

The best way to use ROOT is to run it from a software release that you have already checked out and you are working in. Details of how to set up a software release are given in the WorkBook chapter on Setting up your Working Environment.

If you don't have a release checked out, you can quickly set one up in order to continue this workbook chapter and learn about ROOT with the following commands:

setenv SCRAM_ARCH slc6_amd64_gcc700

cmsrel CMSSW_10_2_18

cd CMSSW_10_2_18/src

cmsenv

If you already have a software release setup, leave out the cmsrel command and do the rest.

You need to do this (apart from cmsrel) every time you want to use the CMS software environment and to use ROOT, as this method sets up the correct paths for you to be able to access the ROOT program which is compatible with the software release that you are currently using.

With those preliminaries completed, start your ROOT session:

root -l

The -l is optional and it speeds up the startup by skipping the start screen.

You are now in an interactive ROOT session, and should see the root prompt.

Most commands in ROOT are delimited by a semicolon, and all commands saved in macros (small files containing several ROOT commands designed to work together to complete a specific task) should be written in strict C++. Additionally, most objects created in ROOT are really pointers to objects. To fully appreciate this distinction you will need to become familiar with the concepts of pointer objects in C++, though the greatest necessity to understand pointer objects when using ROOT is in writing correct C++ syntax for macros, which comes a little later in this WorkBook topic.

Omitting the semicolon at the end of a command, ROOT can be used as a quick calculator, e.g.

45+6

The system should respond with something like:

(int) 51

If you put the semicolon at the end of this line, no return value would be displayed.

The next important step that you must know if you are to use ROOT is how to end a session. To exit a root session, use a dot followed by a q:

.q

Windows and Macintosh (10.12/10.13)

Instructions to set up processes like X11 forwarding to run ROOT remotely from Windows and Macintosh machine are on WorkBookSetComputerNode#XeleVen

Enough ROOT to Run WorkBook Tutorials

Say you have a file called MyOutputFile.root that you wish to examine using one of the analysis modes described in WorkBook chapters 3 and 4. The following sequence of commands loads the file and opens a browsing window, known in ROOT as a TBrowser.

$ root 
root[0] TFile f("MyOutputFile.root");
root[1] new TBrowser

Once you get to the browser, double click down the chain till you get what you're looking for (for example tracks: MyOutputFile.root -> Events -> recoTracks_generalTracks__RECO -> recoTracks_generalTracks__RECO.obj). When you get to a plottable "leaf" (the end of a branch in the tree structure), a double-click will create the plot.

Instead of going through the TBrowser each time, you can set an alias for a branch you want to access. Select a branch name visible in the TBrowser, add obj at the end, and think of a short alias. It's up to you to choose which aliases to use. E.g., set the alias for an object named recoTracks_generalTracks__RECO.obj to tracks:

root[2] Events->SetAlias("tracks","recoTracks_generalTracks__RECO.obj");

Using this alias, go ahead and plot some aspect of the track, e.g., its normalized chi-squared (chi-squared over number of degrees of freedom) :

root[3] Events.Draw("tracks.chi2_/tracks.ndof_");

To use the Python interpreter in ROOT rather than the CINT interpreter, the commands for startup are:

python
>>> from ROOT import *
>>> gSystem.Load("libFWCoreFWLite.so")
>>> FWLiteEnabler.enable()

To load a file and to open a browser, type:

>>> myFile = TFile("MyOutputFile.root")
>>> myBrowser = TBrowser()

For more information, see FWLite in Python.

ROOT Histograms

The main analysis use in ROOT is the production of histograms to represent usefully-binned data. ROOT can produce 1-D, 2-D and 3-D histograms. This WorkBook section will teach you to make create your first histogram, display it, put some data in it, and perform basic histogram manipulations.

Making your first ROOT histogram

We shall create a basic 1-D histogram, declaring it as a pointer object, and will fill it with floating point numbers - the most general histogram application you are likely to want. The required syntax to "book" a histogram is:

TH1F *hist_name= new TH1F("hist_name","hist_title",num_bins,x_low,x_high);

where the various components are:

TH1F

the ROOT 1-D histogram class

hist_name

the name of your histogram - this is how you refer to your histogram to perform manipulations on it. If you save the histo into a file this will be the name by which the histo is stored

hist_title

this title will appear when you print your histogram (either to screen or in hardcopy)

num_bins

an integer defining the number of bins that will appear in the histogram

x_low

the value of the lower edge of the first bin

x_high

the value of the upper edge of the last bin

Histograms in ROOT have two additional bins which are reserve for entries that fall below the bin limits (underflow - bin 0), and for entries that are equal to or larger than x_high (overflow - bin num_bins+1). When booking your histograms you should specify x-low and x-high as real numbers rather than integers, using 10. rather than 10 for example, if you want a bin limit to be the value 10 but to store real numbers rather than have them truncated to integers before being stored.

To book 2-D or 3-D histograms, an analogous syntax is used, for example:

TH2D *h2= new TH2F("2","2d hist title",num_xbins,x_low,x_high,num_ybins,y_low,y_high);

Now to put this into practice. Start up a ROOT session, and book a brand new histogram by entering:

TH1F *hist1= new TH1F("hist1", "My First Histogram", 100, 5., 50.);

Nothing happens! While you have booked your histogram, and therefore created a pointer to a 1-D histogram, to be filled with floats which will be put into 100 bins ranging from 5 to 50, you haven't yet told ROOT to draw it. Do this now with:

hist1->Draw();

The system should respond with something like:

root [1] hist1.Draw()
<TCanvas::MakeDefCanvas>: created default TCanvas with name c1

and a new window (a ROOT "canvas") will be with your new histogram. You should see an empty histogram with the title "My First Histogram", which should look something like:

Histogram manipulations

Filling a histogram with discrete data

Histograms can be filled using the Fill() function in ROOT. Depending on the type of histogram you have declared (number of dimensions, type of data to be input - double/float/...), you can pass numbers to your histogram of the appropriate datatype and the corresponding bin will be incremented. Our new histogram, hist1 has type TH1F, which means that it expects data in the form of floating point numbers. The Fill() function can take individual numbers (which are then filled with weight 1), or can accept weights for numbers (e.g. representing a number of entries at the particular x-value). For example, enter:

hist1->Fill(41,1);
hist1->Fill(12,2);
hist1->Fill(34,3);
hist1->Draw("e");

The last command gets ROOT to draw the updated histogram, producing a result which should look something like:

The ROOT histogram "Print" function

To see information about a particular histogram you need ROOT's Print() function

hist1->Print();

For the histogram created and filled above, the system should respond with:

TH1.Print Name = hist1, Entries= 3, Total sum= 6

To see the entire histogram contents, you want:

hist1->Print("all");

for which the system responds by printing the bin number, the number of entries in each bin, and the values for the upper edge of each bin. Our histogram is fairly empty, so most entries are zero, however a snippet of the output which contains a non-zero entry is:

...
 fSumw[61]=0, x=32.225, error=0
 fSumw[62]=0, x=32.675, error=0
 fSumw[63]=0, x=33.125, error=0
 fSumw[64]=0, x=33.575, error=0
 fSumw[65]=3, x=34.025, error=3
 fSumw[66]=0, x=34.475, error=0
 fSumw[67]=0, x=34.925, error=0
 fSumw[68]=0, x=35.375, error=0
 fSumw[69]=0, x=35.825, error=0
 fSumw[70]=0, x=36.275, error=0
 fSumw[71]=0, x=36.725, error=0
 fSumw[72]=0, x=37.175, error=0
 fSumw[73]=0, x=37.625, error=0
...

To save these numbers, you can dump the contents of a histogram into an ASCII (text) file by directing this output to a file with

hist1->Print("all"); > hist1contents.txt

(remembering to use the semicolon in the command).

Using the stats box

When you plot a histogram using ROOT's default settings, a statistics box appears at the top-right of the plot showing information such as the histogram's name (the histogram title appears at the top left, and is separate to the stats box), the number of entries, mean, etc. The attributes shown in this box are set with the command:

gStyle->SetOptStat(mode);

where mode is a 6-digit number with 1's (on) and 0's (off), represented by the quantities (ourmen)

Some useful points about the stats box:

• if less than 6 numbers are given, e.g. gStyle->SetOptStat(11);, the parameters are read from the right - i.e. in this example, only the number of entries and the histogram name will be shown.
• after changing the SetOptStat() options, you need to redraw the histogram using Draw() to display these updated options
• the stats box options are a property of the ROOT pad - as such, all histograms plotted on the same pad will have a stats box made with the current settings
• to reset to the default settings, use: gStyle->SetOptStat();
• to turn off the stats box entirely, use: gStyle->SetOptStat(0);

Changing the histogram appearance

Other improvements can be made to the readability and presentation of your histogram - for example changing colours, labelling axes, changing font types and sizes. Some of these options are described in this section, while further options for improving the presentation of your histogram are given in the section on legends.

Colours in ROOT are defined through 8 default numbered colour references (plus White) and through a selection of enumerated colour types. The numbers you can use to refer to colours are:

To change the colours of the lines plotted in your histogram, try

hist1->SetLineColor(2);
hist1->Draw();
hist1->SetLineColor(kBlue);
hist1->Draw();

Please do not use colours 3 (light green), 5 (yellow) and 7 (cyan) in your presentations as they will not be visible when your slides are projected.

A few other options that you can explore to enhance the appearance of your histogram are:

hist1->GetXaxis()->SetTitle("Label of x axis");
hist1->GetYaxis()->SetTitle("Label of y axis");

gROOT->SetStyle("Plain");             // Turns off ROOT default style
gPad->UseCurrentStyle();              // removes red box about histo, all Black/White
gROOT->ForceStyle();                  // ROOT needs encouragement to change its style

Finally, to get larger labels, put in some axis titles and add Greek fonts to your histogram:

gPad->SetLeftMargin(0.15);    // experiment with the best value for you.
                              // Depends on font size for your text
 gPad->SetBottomMargin(0.15);

hist1->SetLabelSize(0.05,"y");
hist1->GetYaxis()->SetTitleSize(0.05);

hist1->SetLabelSize(0.05,"x");
hist1->GetXaxis()->SetTitleSize(0.05);

hist1->SetXTitle("`f[#circ]"); // degree symbol, just like LaTeX,
                                // (using "#" instead of "\")
hist1->SetYTitle("Entries / bin");
hist1->Draw();

Comparing two histograms

A common use of histogramming ROOT is to compare two (or more) distributions. This can be achieved by plotting the histograms on the same canvas (in fact, on the same pad, to see them overlapped). More usefully, the histograms should be plotted in different colours and a key (referred to in ROOT as a legend) should be provided to clearly distinguish between the distributions.

Plotting two histos on one canvas

To show how to plot two histograms on one canvas (one pad, in fact, in this example), we need to quickly book and fill a few bins of a new histogram:

TH1F *hist2 = new TH1F("hist2","Another Histogram", 100,2.,100);
hist2->Fill(45,10);
hist2->Fill(20,6);
hist2->Fill(13);

When you draw the histogram, hist2->Draw();, by default ROOT clears the current active pad and freshly draws the new histogram. We can however force ROOT to display both histograms at the same time, with:

hist2->Draw();             //draw our brand new histogram
hist1->Draw("same");   //draw our original histogram on the same pad as hist2

Putting this new knowledge together with what we have learned about setting colours, we can clear the canvas and plot both histograms with different colours:

c1->Clear();                   //remember that this is the name of the default canvas

hist1->SetLineColor(8)       //green
hist2->SetLineColor(4)       //blue
gStyle->SetOptStat(11);      //Display title and total number of events only
hist2->Draw();               //draw hist2 first as it has a larger range
hist1->Draw("same");

The two histograms on the same canvas should look something like:

Note that unless you manually set the axis ranges, these will be set to the most appropriate values for the first histogram which was drawn.

Adding a legend and further text to your histogram

We now need to add a legend to our masterpiece to be able to distinguish between the two plots. It is often also useful to add some additional descriptive text. Since these tasks are similar, they will both be handled in this section.

To add a legend to your histogram, we can do:

leg = new TLegend(0.6,0.7,0.89,0.89);  //the coordinates put the legend corners
                                       //various fractions of the way along the canvas
leg->AddEntry(hist1,"First histo","l") //"l" for a line
leg->AddEntry(hist2,"2nd histo","l")   //use "f" for a box to show which colour
leg->Draw();
leg->SetHeader("My first histos");     //Might as well add a label to the legend box
leg->Draw();                           //Draw updated legend with title

Other useful legend drawing options include:

leg->SetTextSize(0.04);                //change size of legend text
leg->SetFillColor(0);                  //have a white background on the legend box

Text boxes are added similarly, they are called TPaveText objects.

TPaveText *pt = new TPaveText(0.20,0.7,0.5,0.87,"NDC");
                 //note the strict C++ syntax (not required for interactive CINT)
                 // NDC sets the coordinates relative to the dimensions of the pad
                 // useful if you might change the layout of your histos
pt->SetFillColor(0);  //text now is black on white
pt->SetTextSize(0.04);
pt->SetTextAlign(12);

text = pt->AddText("Whatever you want");

pt->Draw();       //to draw your text object

Copying histograms

Identical copies of histograms can be made by cloning, with the command

TH1F *new_hist=(TH1F*)hist1->Clone();
new_hist->SetName("new_hist");

Adding error bars

Error bars can be added to ROOT histograms by drawing the histogram with the option esame:

hist1->Draw("esame");

By defaut, errors shown are the square root of the bin entries. To show error bars as sqrt(sum of weights), before filling your histogram, issue the command:

hist1->Sumw2();

Some drawing options for 2-dimensional histograms

There are many different drawing options available for histogramming in ROOT - you could consult http://root.cern.ch to discover some of the possibilities. Drawing options that you might like to experiment with for 2-D histograms include

hist2->Draw("text");
hist2->Draw("col");
hist2->Draw("colz");
hist2->Draw("box");
hist2->Draw("surf");

Saving and printing histograms

Saving histograms as image files

Histograms can be saved from the ROOT canvas as image files in ps, eps or gif formats (as well as in C++ macros see Source Code section)

To save your histogram to an image file, plot it (assuming here it is plotted on the default canvas c1), then save your file in the desired format by stating the extension you want:

c1->SaveAs("histoimage.eps");
c1->SaveAs("histoimage.ps");
c1->SaveAs("histoimage.gif");

Alternatively you can click on "File" in the upper left corner of the canvas and use the save options in that menu.

Saving histogram source code

Any histogram which is plotted is described by an underlying set of C++ source code. You can save that source code in a file to later rerun (e.g. to change titles or other attributes of the histogram) with the command (assuming your histogram is printed on the default canvas, "c1"):

c1->SaveAs("myimage.C");

Alternatively, you can save the file by clicking on the options "File", "Save", and selecting c1.C.

You can then recreate the histogram in exactly the same from that you saved it in a brand new ROOT session by entering:

.x c1.C

(or select "SaveAs", and select myImage.C). To execute the macro c1.C and create a histogram with the entries and layout that you saved. It is also possible to directly edit the c1.C file that you created.

You should try saving an empty histogram (so that the data doesn't hide the details of the histogram definition) and look through the resultant source code file, as it contains useful commands for defining how your histogram looks.

Inspecting histograms saved infiles

You can look at histograms which were created in ROOT and saved to files, generally with the extension .root. Say you have a ROOT file called "myHistofile.root", you can open it with:

TFile f("myHistofile.root");

where this command is a CINT shorthand to open the file and and load its contents into a temporary file in your ROOT session called "*f*". To look at the contents of the file enter:

f.ls();

And a listing will show the filename, list histograms, and also list any directories or other objects that are present in the ROOT file. Having just opened the file, the ROOT focus is on that file, and you can draw the contents, say of a histogram called h1d4 if it was contained within that file with:

h1d4.Draw();

As in the earlier examples, you can add entries to the bins in the histogram with the Fill(...) command, and redraw the output with another Draw() command.

Accessing histograms saved in files

Loading an existing ROOT histogram

A histogram which is already loaded into a ROOT session, e.g. having been created or loaded from a file, can be accessed by creating a pointer to it with the command

TH1F myHist=(TH1F) gDirectory->Get("name of histogram");

Changing between active files

When you have more than one open ROOT file, ROOT keeps its focus on only one file at a time. You can operate on any of the opened files by referring directly to those files using their reference names (e.g. "file1" in the example below). Additionally, if you have opened two files with, say,

TFile *file1=new TFile("firstfile.root");
TFile *file2=new TFile("secondfile.root");

you can perform actions on the first file you opened by changing ROOT's focus to that file with:

file1.cd();

Similarly, you can change back to the other file when you want to address file2. This enables you to open several files and move between them using potentially the same commands on objects saved in each file.

Getting help with ROOT

ROOT tutorials

Many useful ROOT tutorials can be found on the web. Often these provide solutions to problems, or at least some sample code to get started on a particular task. You should beware that some of the information in the following tutorials is specific to the particular experiment or institute the tutorial was designed for, however the following tutorials contain very useful information:

• The ROOT system homepage, Official tutorials, How-Tos (very useful)
• BaBar WorkBook first two ROOT tutorials: ROOT1: Basics Root2: Further Use
• !BaBar Interactive ROOT tutorial
• Fermilab's ROOT resources

Acknowledgement

This Introduction to ROOT WorkBook topic originates from the Babar Workbook chapter Root I (original author: JennyWilliams).

Review Status

A.5 A 30-Second Introduction to SCRAMv1

SCRAM (Source Configuration, Release, And Management tool) is the CMS build program. It is responsible for building framework applications and also making sure that all the necessary shared libraries are available. There are two versions of SCRAM. SCRAM v0.2 is used for the LCG projects SEAL and POOL and early versions of ORCA, while SCRAM v1 is used for the newer CMSSW. We will only talk about SCRAM v1 here.

Main Commands

1. To build subdirectories of the current directory:

$ scram build
$ scram build MyAnalysis

$ cmsenv

$ scram project CMSSW [version]

$ scram build 
$ scram build clean

Useful Options

scram b -f

Skip reading the cache; useful for when you know that no BuildFiles or source files have been modified, added or removed. Seems that modified source file (under src/) are no problem, as they are build as expected.

scram b -v

Verbose mode: show the full compilation/linking commands.

scram b -k

Continue building after any errors from Make

scram b -j [n]

For building in parallel using [n] processes (same as -j of GMake)

For more detail on SCRAM please read SWGuideScram
For more detail on SCRAM Buildfiles please read the WorkBookBuildFilesIntro.

Review status

Responsible: ShahzadMuzaffar
Last reviewed by: ShahzadMuzaffar - 17 Nov 2009

A.6 On BuildFiles

Complete:
Detailed Review status

Package BuildFiles

SCRAM uses a file called CMS.BuildFile in each package directory which describes what the package will produce and what dependencies the package has. Consider the following CMS.BuildFile from the tutorial:

<use name="root"/>
<use name="DataFormats/HcalRecHit"/>
<use name="TBDataFormats/HcalTBObjects"/>
<use name="FWCore/Framework"/>
<use name="FWCore/ParameterSet"/>
<flags EDM_PLUGIN="1"/>

The first part of the CMS.BuildFile tells SCRAM what packages or external libraries (e.g., ROOT) are needed to build this package. The <flags> line is needed because this package contains a framework module (in this case, your analyzer) which must be registered with the plugin system .

Other BuildFiles

Here we give some examples of CMS.BuildFile snippets for test executables, test libraries and normal (application) executables.

Public shared libraries

In the MySubsystem/MyPackage/CMS.BuildFile, defines shared libraries which others CMSSW packages can link using

<use name="MySubsystem/MyPackage"/>

in their BuildFiles. The convention for library names in CMSSW is SubsystemPackage, where the directory containing the BuildFile is Subsystem/Package. Those familiar with ORCA might be used to libraries named after only the Package, but this change was made to simplify code management in CMSSW.

<use name="root"/>
<use name="DataFormats/HcalRecHit"/>
<use name="TBDataFormats/HcalTBObjects"/>
<use name="FWCore/Framework"/>
<use name="FWCore/ParameterSet"/>
<export>
  <lib name="1"/>
</export>

EDM Plugins

In the plugins directory of a package, define EDM plugins using library tags. More than one plugins can be defined. If they share dependencies, a common dependencies block can be used. If there are dependencies which are unique to one plugin, they should be placed inside the library tags:

<use name="tool1"/>
<use name="Subsystem/Package1"/>

<library name="myplugin1" file="plugin1.cc">
</library>

<library name="myplugin2" file="plugin2.cc">
  <use name="tool3"/>
</library>

Test executables

In the test/CMS.BuildFile directory of a package, define a binary executable using "bin" tags.

<use name="tool1"/>
<use name="Subsystem/package1"/>

<bin name="mytest1" file="main.cpp"/>
</bin>

<bin name="mytest2" file="main.cpp">
  <use name="tool3"/>
</bin>

Note that the same treatment of dependencies follows as described above in plugins.

Binary executables for real applications

Binary executables which are real applications should be executable from the command-line, i.e. they will be found in the user PATH after scram runtime is set. These executables are defined in a CMS.BuildFile in a bin directory in a package (i.e. package/bin/CMS.BuildFile). For example:

<bin name="myApp1" file="main.cpp">                                                          
  <use name="tool1"/>                                                               
  <use name="Subsystem/package1"/>
</bin>  

Note that the same treatment of dependencies follows as described above in test.

Building binary and test executables from more than one source file

This might come up when linking a main() against a private class. Assume that the class is called XYZ, is declared in XYZ.h, and XYZ.cc contains the implementation:

<bin name="myPrivateApp1" file="main.cpp,XYZ.cc">                                       
  <use name="tool1"/>                                                                         
  <use name="Subsystem/package1"/>
  <use name="Subsystem/package2"/>                                            
</bin>  

For more detail on SCRAM Buildfiles please read SWGuideBuildFile

Review status

Responsible: ShahzadMuzaffar
Last reviewed by: ShahzadMuzaffar - 17 Nov 2009

Glossary and Index

A reference document for information and explanations of acronyms and common terms in the CMS computing, grid-computing, detector, high energy physics and analysis environments.

The WorkBook Glossary is continually being updated with new and improved definitions of acronyms and concepts relating to the CERN, the CMS experiment, the LHC and GRID computing.

The context for the glossary item is given in brackets in italics at the start of the item dealscription.

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

A

AB

Algorithm Board

AC

• Alternating Current
• (organisation) Authorship Committee

Account

(computing)

• CERN Computing Account: WorkBookGetAccount#CernAccount
• Local Computing Account: WorkBookGetAccount#LocalAccount

Acknowledgements

(workbook) WorkBookAcknowledgements

ADC

(detector) Analog to Digital Converter

ADD

(physics) Arkani-Hamed-Dimopoulos-Dvali (ADD) model, arXiv:hep-ph/9803315

AFD

(safety) Automatic Fire Detection

AFEB

(detector) Anode Front-End Board, CSC system

AFS

(computing) Andrew File System

AG

Application Gateway

AL3

(safety) Alarm Level 3

AlCaRECO

(analysis) Alignment and Calibration Reconstructed files: AlcaReco data is the special RECO data for the alignment and calibration tasks. It is produced similar to Prompt Reconstruction, in that RAW data is reconstructed using standard CMSSW algorithms to produce the standard RECO data format. However, only regional reconstruction is performed, and only the parts of the event needed for the specific alignment or calibration task are written out. AlcaReco RAW data is likely to be written as a separate online stream, because it must be processed with very low latency.

ALCT

Anode Local Charged Track trigger primitive, CSC system

Algorithm

(analysis) In the RecAlgorithm system, algorithm objects are entities that create new resulting objects or transform input objects. In the EDProducer systems, we distinguish between EDProducers and other algorithms that can perform smaller steps of reconstruction, and that may be composed (i.e. combined) to form an EDProducer.

ALICE

A Large Ion Collider Experiment

Analysis Object Data (AOD)

(analysis) AOD are derived from the RECO information. They are intended to contain, in a convenient, compact format, enough information about the event to support all the typical usage patterns of a physics analysis. They are usable directly by physics analyses. AOD data are produced by the same, or subsequent, processing steps as those that produce the RECO data, and are available at Tier-2 sites (unlike the full RECO data). Reference: WorkBookDataFormats#AoD

ANN

(analysis) Artificial Neural Network

%ACRO% AOD

(analysis) see entry for Analysis Object Data entry.

AOH

(detector) Analog Opto-Hybrid - front-end readout optoelectronics board for CMS Tracker

APD

(detector) Avalanche Photo-Diode

APE

alignment position errors : an additional error applied to the reconstructed hits in order to take misalignment into account in the tracking and refitting.

API

(computing) Application Program Interface

APV

(detector) Analogue Pipeline (Voltage mode), front-end read-out chip of Tracker

APVe

(detector) APV emulator. Reference: CMS.APVeOverview

APV25

(detector) Analogue Pipeline chip, Voltage-mode, 0.25 micrometer technology. Reference: CMS.APVeOverview

ARC

(analysis) Analysis Review Committee

ARC

(grid) Advanced Resource Connector (Grid middleware used in the Nordic countries)

ASIC

(detector) Application Specific Integrated Circuit

ATEX

(safety) ATmosphere EXplosible

ATLAS

(detector) A Toroidal LHC ApparatuS experiment

aTTS

Asynchronous Trigger Throttle System

AUP Acceptable User Policy

(grid) the document you sign to get grid access that tells you what you can and can not do

AWG

American Wire Gauge

B

B1

Beam 1

B2

Beam 2

Bare ROOT

(analysis) Using the ROOT framework to analyse data without accessing the full functionality of the CMS framework. Accesses only member data of classes stored in data files, not the methods of those classes. Reference: WorkBookMakeAnalysis#BareRoot

BCM

(detector) Beam Condition Monitor

BCM1F

(detector) Beam Condition Monitor "Fast"; part of the BRIL sub-system.

BCM1L

(detector) Beam Condition Monitor for Losses; part of the BRIL sub-system.

BCN

Bunch Count Number

BCS

Beam Scintillation Counters

BD

Back Disk

Beam Radiation Monitor (BRM)

(detector) Monitoring and early-warning system for onset of dangerous beam conditions. Designed to protect personnel and particularly the CMS detector, as well as other LHC systems. Reference: CMS.BrmWikiHome

BIC

(safety) Beam Interlock Controller

BIW

(safety) Beam Injection Warning

BMU

(detector) Barrel Muon system

BOBR

Beam Observation system Beam synchronous timing Receiver

Book-keeping

(computing) DBS - Database Book-keeping System: WorkBookDataSamples#RvS

BP

Back Petal

BPix

Barrel Pixel

BPTX

Beam Pickup for Timing for the eXperiments, part of BRM

BR

Branching Ratio

BRAN

Beam RAte of Neutrals

Branch Name

(analysis) For all data that will exist in a form that is traversable and browsable from the ROOT prompt, a branch name is provided. The branch name is composed of a "friendly" product type name, a process name and a module label.

BRIL

(detector) the Beam Radiation, Instrumentation and Luminosity sub-detector system. Composed of three sub-detectors (BCM1F, BCM1L, PLT) segmented into four modules.

BRM

see entry for Beam Radiation Monitor

BSC

Beam Scintillation Counter

BSM

(physics) Beyond Standard Model. Includes such models as SuperSymmetry and Technicolour, but generally describes any physics that extends the current standard model of particle physics.

BST

Beam Synchronous Timing

B-tag

B-tagging associates a single, real number - a discriminator - with each jet.

BTI

Bunch and Track Identifier trigger primitive, DT system

BU

Builder Unit

BTV

b Tag & Vertexing Physics Object Group

Build File

(analysis) Each CMSSW package directory has a file called a "BuildFile" that describes what the package will produce (executable files, etc) and what dependencies the package has. Reference: WorkBookBuildFilesIntro

Buildings

Find onsite CERN building locations: WorkBookHelp#SearcHingCERN

BX

Bunch crossing

BXN

Bunch Crossing Number

C

C++

Primary programming language used in CMS. Programme reference: WorkBookComputingConcepts#ProgLan

CA

Certification Authority (Grid)

CAD

(analysis) CMS Analysis Database

CADI

(analysis) CMS Analysis Database Interface

CAF

(CERN Analysis Facility) Integrates services associated with T1 and T2 centers and performs latency critical, non-automated activities.

CASTOR

(computing) CERN Advanced STORage Manager. Reference: http://castor.web.cern.ch/castor/

CASTOR

(detector) Forward Calorimeter: Centauro And STrange Object Research in nucleus-nucleus colllisions at the LHC. Reference: CASTOR

Candidate Combiners

WorkBookParticleCandidates#CandComb

Candidate Selectors

WorkBookParticleCandidates#CandSel

CASTOR

WorkBookSetComputerNode#ManyLargeFiles

CB

(organisation) Collaboration Board

CC

• Cosmic Challenge
• (organisation) Conference Committee (CMS)

CCC

 

• CERN Control Centre
• (organisation) Conference Committee Chairperson (CMS)

CCE

(detector) Charge Collection Efficiency

CCM

(detector) Clock and Control Module

CCB

Clock and Control Board, CSC peripheral crate electronics board, 1 per pcrate

CCRC

(computing) Combined Computing Readiness Challenge: four weeks challenge in May 08 prepared by preliminary tests in February.

CCS

(detector) Clock and Control System

CCU

(detector) Communication and Control Unit

CCUM

(detector) Communication and Control Unit Module

CDR

• Central Data Recording
• Conceptual Design Review

CDS

CERN Document Server

CE

(grid) Computing Element

CERN

(organisation) European Laboratory for Particle Physics

Certificates

Grid Certificates: WorkBookStartingGrid#BasicGrid

CFC

(detector) Carbon Fiber Composite

CFEB

(detector) Cathode Front-End Board of the CSC system

cfi files

WorkBookWriteFrameworkModule#CreatE

CIE

(safety) Control and Indication Equipment

CINT

A C/C++ interpreter that is embedded in ROOT

CLCT

(detector) Cathode Local Charged Track trigger primitive, CSC system

CLHEP

Class Library for HEP (Software)

CMKIN

(deprecated) WorkBookGeneration#CmkiN

CMM

(detector) Coordinate Measuring Machine

CMN

(detector) Common Mode Noise

CMOS

(detector) Complementary Metal Oxide Semiconductor

CMS

(detector) Compact Muon Soleniod Detector. Reference: WorkBookCMSExperiment#DetectorComponents

CMS Notes

WorkBookHelp#CmsNotes

Cms Remote Analysis Builder (CRAB)

WorkBookCRAB2Tutorial

cmsRun

SWGuideAboutConfigFile

cmssh

(computing) A programmable shell written in python, see WorkBookCmsshTutorial

CMSSW

CMS Software used in offline data analysis including event generation, simulation, and digitisation (for simulated data) as well as reconstruction and analysis (for both simulated and real data). It is also used online e.g. by the StorageManager application.

COCOA

CMS Object-oriented Code for optical Alignment

COM

Color Octet Mechanism

Composite Particle Candidates

WorkBookParticleCandidates#CompCands

Computing Account

WorkBookGetAccount

Computing Model

WorkBookComputingModel

Conditions Database

A database containing information relating to the state of the detector in a particular time interval. Contains information such as calibration details giving accurate positions of detector components. Ecal elements reference: SWGuideEcalOverview#ConditionsDatabase

CondDB

(computing/analysis) see entry for Conditions Database

ConfDB

A configuration database, browser, editor and GUI for the HLT menues

Conference Agendas

WorkBookHelp#AgendaC

Conference Committee

WorkBookHelp#CmsConf

Configuration File (.cfg)

A document specifying which modules, inputs, outputs and services are to be loaded during execution of the cmsRun executable, how to configure these modules and services, and in what order to execute them. Reference: WorkBookConfigFileIntro

Container

An organizational unit within an event, used to collect particular types of data separately.

Contributor Guide

WorkBookContributors

Coordinates

CMSConventions

COSINE

Consistent Online Software INtegration Environment, project integrating online with offline software

CPT

(deprecated) Computing, Physics and Trigger-DAQ. The CMS CPT group essentially covers all computing aspects of CMS operations: including PRS (physics reconstruction and selection), software and development and operations of CMS computing.

CPE

(detector) Cluster Parameter Estimator: algorithm used to determine the position and errors of the CMS Pixel and Strip clusters

CPU

(computing) Central Processing Unit

CRAB (CMS Remote Analysis Builder)

CRAB is a Python program intended to simplify the process of CMS analysis job creation and submission to the grid environment. Reference: WorkBookCRAB2Tutorial

CRack

(detector) Cosmic Rack, a set of TOB rods

CRAFT

(commissioning) Cosmic Run at Four Tesla: Global run of CMS closed and with magnet on.

CRB

Crate Regulator Board - CSC peripheral crate backplane mounted LV power regulator board

CRC

Cyclic Redundancy Check error detection

CRC

(computing) Computing Run Coordinator

CRUZET

(commissioning) Cosmic RUn at ZEro Tesla

CSA06

(computing) Computing, Software and Analysis challenge in 2006. Reference: CSA06

CSA07

(computing) Computing, Software and Analysis challenge in 2007. Reference: CSA07

CSA08

(computing) Computing, Software and Analysis challenge in 2008. Reference: CSA08

CSA14

(computing) Computing, Software and Analysis challenge in 2014.

CSAM

(safety) CERN System for Alarm Management

CSC

(detector) Cathode Strip Chamber muon system

CSCTF

Cathode Strip Chamber Trigger Track Finder

CSM

(physics) Color Singlet Model

CSO

(safety) Cryogenic Safety Officer

CSP

(computing) Computing Shift Person

CSV

Combined Secondary Vertex

CT-PPS

(detector) CMS-TOTEM Precision Proton Spectrometer. Reference: https://cds.cern.ch/record/1753795

CVS

Concurrent Versioning System: WorkBookComputingConcepts#CvsCheckoutModules

CVSweb - web-based tool for searching through CVS repositories, e.g. the CMS Release code. Reference

WorkBookHelp#CVSWeB

CWR

(analysis) Collaboration Wide Review: procedure for reviewing the CMS scientific papers

D

D2S

(data/computing) Data to Surface

DAC

Digital to Analog Converter

DAS

(data/computing) Data Aggregation System

DAQ

(data/computing) Data Acquisition System

DAQMB

Data Acquisition Motherboard, CSC L1 trigger

Data Formats

(data/computing) (DAQ-RAW, RAW, RECO, AOD, TAG, FEVT) WorkBookDataFormats

Data Samples

(data/computing) Finding data samples: WorkBookDataSamples

Data Summary Tape (DST)

(data/computing) deprecated name used to refer to a reduced size dataset containing the most interesting reconstructed objects (see also RECO and AOD formats).

Database Book-keeping System (DBS)

(computing) Tracks dataset locations around the globe. Also sometimes known as Dataset Bookkeeping System. Reference: WorkBookDataSamples#RvS

Dataset

(computing/data) files containing information (list of tracks, momentum, high-level reconstructed objects) about a set of physics collision events recorded from the CMS detector. A dataset might

DB

(computing) Database. Also used often in the context of CMS Computing to refer to the Dashboard monitoring project.

DBMS

(computing) Database Management System

DBS

(computing) See entry for Database Book-keeping System

DC

(computing) Data Challenge: a learning exercise to test operations of large scale computing systems.

DC

(computing) Data Certification

DC

(detector) Direct Current

DCC

(detector) Data Concentrator Card

DCCT

(detector) DC Current Transformer

DCFEB

(detector) Digital Cathode Front-End Board of the (upgraded ME1/1) CSC system

DCS

(detector) Detector Control Systems

DCU

(detector) Detector Control Unit

DD

(physics) Double Diffractive

DDD

Detector Description Database

DDL

Data Description Language

DDT

(organisation) Dataset Definition Team, replaces (announced Mar 2012) Physics Datasets Working Group

DDU

Detector Dependent Unit in DAQ system

Debugging

(computing) See: SWGuideUsersFAQ#Debugging

Detector

(detector) The CMS Detector: WorkBookCMSExperiment#DetectorComponents

Detector Simulation

(analysis) Reference: WorkBookSimDigi#DetSim

Detector Simulation Model (OscarProducer)

(analysis) Reference: WorkBookSimDigi#DetSimMod

DFS

Microsoft Distributed File System deployed at CERN. Web access (requires NICE login), your quota.

Digis

(analysis/data) detector event data as output by the electronics (in simulation: as output by digitizer modules. See also Digitizer). Reference: WorkBookDataFormats

Digitization

(analysis) Reference: WorkBookSimDigi#DigI

Digitizer

(analysis) A digitizer software module takes event input in units appropriate to the readout, e.g., energy from the simulator, or number of photoelectrons from the ECAL subdetector readout, and converts it to digitized (On/Off) data prior to sending it to the trigger. Each subdetector necessarily has its own digitizer, according to the type of readout data. For generated data, the digitizer can be viewed as part of the simulation application.

DIP

Data Interchange Protocol (CERN)

DLS

(computing) Data Location Service

DM

(computing) Data Management

DMB

DAQ MotherBoard of CSC system

DMR

(analysis) Distribution of Median of Residuals, used in alignment of the Tracker

DMWM

Data Management Workflow Management

DN

(grid) Distinguished Name, a.k.a. the Subject of a GRID certificate, -- a globally-unique GRID-user name consisting of a hierarchical set of the following components: Country (C), Organisation (O), Organisational Unit (OU), Locality (L), Common Name (CN). Example: ​/C=RU​/O=RDIG​/OU=users​/OU=itep.ru​/CN=Vladimir Ivanov.

Documentation

(CERN/CMS) CERN and CMS documentation: WorkBookHelp#DocumenTation

DOFZ

(detector) Diffusion Oxygenated Float Zone Silicon

DOH

Digital Opto-Hybrid - front-end control ring optoelectronics board for CMS Tracker, ECAL, RPC, TOTEM

DOHM

Digital Opto-Hybrid Module

DORP

Data Operations and Release Planning

Dosimeters

(radiation protection) Radiation dose measurement devices. Reference: WorkBookComingToCERN#DoSi

Doxygen

(programming) Automatic code-generating system for inter-related C++ packages. Reference: WorkBookHelp#DogyGeN

DPG

(detector) Detector Performance Group

DQM

(data-taking) Data Quality Monitoring: task or application for checking the quality of CMS (event) data.

DQMC

(data-taking) Data Quality Monitoring Collector

DSS

(detector) Detector Safety System

DCS

(detector) Detector Control System

DST

(analysis) see entry for Data Summary Tape

DT

(detector) Drift Tube muon system

DTTF

(trigger) Drift Tube Track Finder system, DT L1 trigger

DV

(_ detector _) Data Valid, a bit set by the HCAL Half-HTR for each signal sample

E

EAM

(safety) Experimental Area Manager

EB

(data acquisition) Event Builder

EB

(detector) ECAL Barrel

EB

(management) Executive Board

EBTCC

(detector) ECAL Barrel Trigger Concentrator Card (see TCC)

ECAL

Electromagnetic Calorimeter. CMS.ECALWikiHome

• Ecal clustering: SWGuideEcalRecoClustering
• Ecal overview: SWGuideEcalOverview
• Ecal reconstruction: WorkBookEcalReco
• Ecal reconstruction tutorials: SWGuideEcalRecoTutorials

ECNA

ECAL Correlated Noise Analysis

ECoM

(computing) Evolution of Computing Model Group (2008)

EDAnalyzer

A CMSSW framework module that analyzes event data and may or may not store output into a ROOT output ntuple. The analyzer does not alter the stored the Event. Reference: WorkBookMakeAnalysis#EdAnalyzer

EDFilter

A CMSSW framework module that can read an event and make a decision whether or not to process it

EDG

European Data Grid project

EDM

Event Data Model. Reference: EDM

EDMS

Engineering Database Management System

EDProducer

A top-level, reconstruction-developer written CMSSW framework component that performs a quantifiable step of reconstruction by creating and storing persistable data in the Event. An EDProducer instance produces an EDProduct instance. Any EDProducer class may be used for scheduled and unscheduled applications. Reference: WorkBookEDMTutorialProducer

EDProduct

The output of a CMSSW EDProducer module. An EDProduct is the base class for all objects inserted into the Event.

EDR

Engineering Design Review

EE

(detector) ECAL Endcap

EEE

Eta-extended electrons

EETCC

(detector) ECAL Endcap Trigger Concentrator Card (see TCC)

EF

Event Filter, see entry for event filter

EGEE

The Enabling Grids for E-sciencE (EGEE) project, funded by the European Comission, is aimed to build on existing grid technology to develop a constantly-available grid infrastructure for scientists

EGI European Grid Initiative

an European Community project to operate seemlessly a network of National Grid Initiatives (NGI) after EGEE is over

EIC

Electromagnetic Isolation Card, regional calorimeter trigger

ELMB

Embedded Local Monitoring Board (ECAL)

EMDB

Equipment Management DataBase

Email

• CERN Email: WorkBookHelp#EmAil
• My Mail and More: WorkBookHelp#MmM

EMU

Endcap Muon system

ENC

Equivalent Noise Charge

Encryption

a procedure that renders the contents of a file unintelligible to anyone not authorized to read it

Environment Setup

WorkBookSetComputerNode

EOS

(computing) an XRootD-based storage system (a disk pool) at CERN for analysis-style data access. Web references: cern, cms

EP

Event Processor

EPR

Experimental Physics Responsibility, name given to the service work that should be provided by each CMS institution/author

ES

Endcap preShower detector

ES

Event Server

ES

Event Setup.

ES

ESsource, ESproducer

ESD

Event Summary Data

ESP

Event Server Proxy

ESP

(organisation) Experiment Services and Pledges, the tool (http://cms.cern.ch/iCMS/admin/espmanagement) which is used to manage and account the services to the experiment provided by Institutes and Members under the Memorandum of Agreement (MoA)

ESS

ECAL Safety System

Et

(physics) Transverse Energy

ETTF

Eta Track Finder, DT regional muon trigger

EVB

EVent Builder

Event

an event is set of signals in the detector resulting from a pp collision, or several such coincident collisions, either in reality in CMS or as produced by a simulation program. It includes raw signals (e.g. tracker hits, calorimetric energy deposits, etc.) and derived quantities (e.g. tracks, jets, etc.). In software terms, an event starts as a collection of the raw data from an event, stored as a single entity in memory, but organized into containers. The contents of the event change as it is processed; in particular, products (of producer modules) get added to the event, and are stored in separate containers. The Event is the interface through which one gains access to detector output and derived quantities that are associated with a single colllision.

Event Collection

A set of events typically with similar characteristics - e.g. similar detector conditions, similar event characteristics, ...

Event Data Model

WorkBookCMSSWFramework#EdM

Event Display

The CMS Event Display is IGUANACMS: WorkBookEventDisplay

Event Filter (EF)

A module whose primary purpose is to render a decision on the quality of an event, based on the EDProducts in the event.

Event Formats

WorkBookDataFormats#EvenT

Event Generation

WorkBookGeneration

Event Mixing Module

An EDProducer module that superposes events and delivers them to the detector-dependent digitization modules. For simulated data, it merges hits from a number of pileup simulated events into a single simulated event.

Event Setup

An event setup is a code block that might be included in a general information process block. The block source grabs information from an external source, for example the calibration database, in preparation for beginning an analysis job.

• es_source SWGuideAboutConfigFile#EsS
• es_module SWGuideAboutConfigFile#EsM

EVF

Event Filter Farm

EVM

Event Manager

EVO

Enabling Virtual Organization (video conferencing/colloboration system). "EVO is an advanced collaboration system based on a completely new and revolutionary distributed architecture capable of automatic self-correction to provide the best possible quality/experience for the end-users", WorkBookHelp#EvO

EW

Electroweak

EWK

Electroweak. Also: Electroweak physics group.

Expressline

(data-taking) The Expressline is 10% of the data that is tagged by Online and then processed (reconstructed) as quickly as possible, even before getting the calibration constants from the PromptCalibration. The Expressline data fully overlaps the main stream of data, i.e. there is no event in the Expressline that is not also in the non-express data streams. The Expressline data will be made available in the CERN CAF disk pool as fast as possible, to allow immediate analysis.

F

FA

(organisation) Funding Agency

FAQ

(general) Frequently Asked Questions

FB

• (organisation) Finance Board
• (safety) Fire Brigade

FBO

(DAQ) Fedbuilder Output: xdaq-applicaton running in the computers hosting the RU that receives the superfragments of the fedbuilder. See also the DAQ Glossary.

FC

(computing) File Catalogue

FCC

Future Circular Collider, the working name for a proposed project at CERN

FCAL

(detector) Forward Calorimeter

fCSA08

(computing) Final CSA08: further exercises for LHC collisions to be performed in July (if beam is not imminent).

FDC

Forward Detector Concept Working Group, aiming at the development of long-range strategies for the CMS Upgrade Program in the endcap and forward regions including tracking, calorimetry, muons and trigger (concept Mar 2012)

FDL

Final Decision Logic

FE

(detector) Front End

FEC

(detector) Front End Controller

FED

(_ detector_) Front End Driver

Feedback

(general) providing feedback: WorkBookUsage#ProvideFeedback

FEH

(detector) Front End Hybrid

Fermilab

Work from FNAL computers: WorkBookRemoteSiteSpecifics#CMS.FermiLab

FEVT

Full Event information - this is the RAW (straight from the detectors) plus RECO (undergone some reconstruction) data - the two streams are kept together in CMS. Reference: WorkBookDataFormats

FGSO

(safety) Flammable Gas Safety Officer

Filter

see entry for event filter

Find data

Finding data samples: WorkBookDataSamples

FNAL

Fermilab

FOG

(organisation / trigger) Field Operations Group within the Trigger Studies Group (TSG). Responsible for the online deployment and monitoring of the HLT. Reference: CMS.FieldOperationsGroup

FORTRAN

Programming Language. Mostly superceded in high energy physics by C++ (e.g. Herwig Monte Carlo is now Herwig++)

FPGA

Field Programmable Gate Array

Framework

a C++ class library that defines the form of all user classes and the interactions between these classes. It provides the mechanism for job control to be passed from the operating system (i.e., the computer) to CMSSW code. The CMSSW framework implements a software bus model wherein there is one executable, called cmsRun, and many plug-in modules that run algorithms. The modules are chained together to process data. The same executable is used for both detector and Monte Carlo data. This framework is distinct from a more traditional approach in which several executables are used, one per task or set of tasks.

FPIX

Forward Pixel Detector

Framework-Lite

Analysis modality whereby all functions and data members of a class are accessible by automatically-loaded ROOT libraries in an interactive ROOT session. Reference: WorkBookMakeAnalysis#FwLite

Framework services

These are services, such as the error logger and debugging service, that provide feedback about the state of the Framework (e.g. what module is presently running and meaningful error messages for debugging).

FRL

(data) Front End Readout Link

FROG

the Fast and Realistic OpenGL event displayer is a generic tool to visualize events. It can be use in CMS as well as in other experiment. More informations can be found on FROG webpage : http://projects.hepforge.org/frog/ or on the TWiki page : https://twiki.cern.ch/twiki/bin/view/CMS/FROG.

Frontier

A world-wide distribution and caching system for the Conditions Database. An online version is used by the HLT. http://frontier.cern.ch/

FSC

(detector) Forward Shower/Scintillator Counters -- subdetectors to detect particle showers along the beam pipes (installation: 2012?)

FSM

(detector) Finite State Machine

FSQ

(organisation) the Forward and Small-x QCD Physics Analysis Group (PAG), the result of a merge in 2012 of Forward PAG and Low pT QCD subgroup. Subgroups as of Jan-2012: (1) Small-x QCD, (2) Soft QCD & MPI, (3) Diffraction & Exclusive processes (more details).

FSR

Final State Radiation

FTE

(organisation) Full-Time Equivalent -- a fraction of the full working time (usually over the time period of one year) that a person devotes to a project

FTP

File Transfer Protocol

FU

(data) Filter Unit

FW

(analysis) Framework

FWLite

see entry for Framework-Lite

G

GACL

(computing) Grid Access Control List

GAPD

Geiger avalanche photo diode (also called SiPM)

Gaudi

(analysis) LHCb Data Processing Applications Framework

GCT

(trigger) Global Calorimeter Trigger (part of the L1 trigger). Reference: SWGuideGCTEmulator

GEANT

Pan-European Gigabit Research and Education Network

GED

Global Event Description, aka PF (the Particle Flow approach)

GEM

(detector) Gas Electron Multiplier

GEN

GENerator level data. Reference: WorkBookDataFormats

Geant 4

A toolkit for simulation of the passage of particles through matter

Generator (of Events)

A physics event generator is software that uses Monte Carlo methods to simulate particle collisions and subsequent decays according to theory. Simulated particle events may then be run through the detector simulation to account for the effects of interactions with matter such as energy loss and bending of charge particles in the magnetic field. Pythia is the primary generator used in CMS to model the multiparticle output of a "real" collision of a given type. A generator called a "single particle gun" is used to generate a single particle of a given type; this is particularly useful for testing purposes.

• Generating events: WorkBookGeneration
• Monte Carlo Generators: WorkBookGeneration

Geom (.geom file extension)

This is the file extension of the FROG file containing the geometry data.

Getter

CMSSW entity that provides an interface through which a single EDProduct is obtained.

GGM

Gas Gain Monitoring system for the RPC muon detector

GID

Global Event Identifier

GLB

Global muon reconstruction. It is made out of the fit of the hits from the track build in the tracker with the ones from the STA.

GLIMOS

(safety) Group Leader In Matters of Safety

gLite

Lightweight middleware for Grid Computing

Global run

(data taking) data taking exercise involving central DAQ, triggered by Global Trigger and with at least one subdetector read-out

Global tag

(analysis) entry point for a coherent set of detetcor conditions, see SWGuideFrontierConditions

Globus

Grid Middleware

GMT

(trigger) Global Muon Trigger. Reference: SWGuideL1GMTEmulator

Goals

Physics of the CMS Experiment at the LHC: WorkBookCMSExperiment#PhysicsGoals

GOH

(detector) Gigabit Optohybrid - front-end readout optoelectronics board for CMS ECAL

GOL

gigabit optical link

GR

Global Run

Grid Certificates

(grid) WorkBookStartingGrid#BasicGrid

GRID computing

(grid) WorkBookStartingGrid

CMS.GridFTP

(grid) Protocol Extensions to FTP for the Grid

GRUMM

(data taking) Global Run Mid-March

GS

(safety) General Infrastructure Services Department

GSF

(pixel reconstruction) Gaussian Sum Filter

GSI

(grid) Grid Security Infrastructure

GT

(trigger) Global Trigger. Reference: SWGuideGlobalTriggerEmulator

GTL

Global Trigger Logic

GUI

(general computing) Graphical User Interface

GUID

(grid) Globally Unique IDentifier

H

Half-HTR

one of two processing units hosted on one HCAL Trigger and Readout card. See DCC and Spigot. (detector)

Harvesting

(data taking) second step of the DQM workflows for offline data or MC - merging of histograms across several files, postprocessing and automated tests. Reference: DQMOffline#SecondStep

HB

(detector) CMS Hadronic Calorimeter, barrel section. Hadron Barrel Calorimeter. Reference: CMS.HCALWikiHome

HBOOK

(analysis) Legacy histogramming package based on Fortran

HCAL

(detector) Hadronic Calorimeter

• Hcal Reconstruction: WorkBookHcalReco

HE

(detector) CMS Hadronic Calorimeter, end-cap section. Hadronic End-cap Calorimeter.

HE-LHC

High Energy LHC -- an option for the LHC machine development aiming at 16+16 TeV pp collisions after ~2030, see a timeline in CERN Bulletin

HECTOR

(software) Particle transport software. Reference: HECTOR

HEP

(general) High Energy Physics

HepMC package

(analysis/computing) An object oriented event record written in C++ for High Energy Physics Monte Carlo Generators. See HepMC home page .

Help

• Useful CERN/CMS web pages: WorkBookHelp#MainWeb
• Useful resources and vital information WorkBookHelp
• User Support pages: http://cmsdoc.cern.ch/cms/cpt/UserSupport/helppage.htm

HF

(detector) Hadron Forward Calorimeter - hadronic calorimetry instrumentation at each end of the main CMS barrel. Reference: CMS.HFWikiHome

HFM

(detector) the "minus" part (z < 0) of Hadron Forward Calorimeter

HFP

(detector) the "plus" part (z > 0) of Hadron Forward Calorimeter

HIP

(physics) Highly Ionizing Particle

Histograms

(analysis) WorkBookWriteFrameworkModule#AddHisto

HL-LHC

High Luminosity LHC -- a project to upgrade LHC around the year 2020 aiming at a substantional increase of the luminosity by a factor of ~10, see a timeline in CERN Bulletin

HLT

(trigger) Higher Level (software) Trigger

HO

(detector) Hadron Outer calorimeter: hadron calorimetry outside the soleniod

hodoscope

(detector) a scientific instrument that detects the passage of a charged particle

HPA

(analysis) High Priority Analysis, e.g. HPAs 2012

HPD

(detector) Hybrid Photo Diode

HPS

(detector) High Precision Spectrometer(s), new subdetectors being proposed for forward proton measurement.

HPS

(physics) Hadron-Plus-Strips algorithm (Particle Flow based algorithm for reconstructing hadronically decaying taus with improved treatment of pi0 reconstruction)

HSCP

(physics) Heavy Stable Charged Particle

HSE

(safety) Occupational Health, Safety and Environment Protection

HTML

(internet) Hypertext Mark-up Language - used to specify the contents and format of a hypertext document on the WWW

HTR

HCAL trigger and readout card - location of two Half-HTR's, a top one and a bottom one, by the position of their respective FPGA's.

HTTP

(internet) HyperText Transfer Protocol - a set of instructions for communication between a server and a WWW client

HV

(detector) High Voltage

CMS.HyperNews

A web and email-based collaboration tool used widely in the BaBar and LHC Collaborations. Reference: WorkBookHelp#CMS.HyperNews

I

I2O

Intelligent Input/Output

iCMS

Main CMS information site (web pages). Reference: http://cms.cern.ch/iCMS

iCSA08

(computing, software) Initial CSA08 activities (iCSA08): CMS offline workflows to demonstrate readiness for LHC data (calibration, skims, express analyses).

IGUANA

(analysis) CMS Event Visualization: a generic Interactive Graphics and User ANAlysis software toolkit (C++). Reference: WorkBookEventDisplay#InfoSources

IGUANA CMS

(analysis) is a visualization system for CMS reconstruction and simulation (now part of CMSSW). Reference: WorkBookEventDisplay#InfoSources

Images

(general) CERN/CMS etc pictures and photos: WorkBookHelp#ImaGes

Input Module

(software) In CMSSW, a module responsible for obtaining events.

Installing CMS software on local systems

(infrastructure) WorkBookInstallingCMSSoftware

IOV

(data) Interval of Validity. For example, the range of dates for which detector conditions data is valid

IP

(physics) Interaction Point

IR

(physics) Interaction Region

ISR

(physics) Initial State Radiation

ISR

(general) Intersecting Storage Rings

J

Java

(programming) Programming Language

Jet

Narrow cone of hadrons and other particles produced by the hadronization of a quark or gluon in a particle physics or heavy ion experiment

JME POG

JetMET Physics Object Group

JTerm

January CMS wide educational workshops

K

Kerberos

(computer security) An authentication protocol

• Getting a CERN Kerberos ticket from offsite: WorkBookSetComputerNode#TicKet

L

L1

(trigger) Level 1 (hardware) trigger.

L1A

(trigger) Level 1 Accept signal

LACS

(safety) LHC Access Control System

LASS

(safety) LHC Access Safety System

LAN

(computing) Local Area Network - used to connect computers over a short distance - e.g. in the same office/building

Large files

(computing) Working with large files: WorkBookSetComputerNode#LargeFiles

LAS

(detector) Laser Alignment System

LAS

(computing) Live Access Service

LBDS

LHC Beam Dump System

LCG

(grid) Worldwide LHC Computing Grid project (WLCG): WorkBookStartingGrid#LcG

LDAP

(computing) Lightweight Directory Access Protocol

LDT (as in EE LDT)

LED Diode Timing

LEE

Look-Elsewhere Effect: CMS.LookElsewhereEffect

CMS.LeftBar

(documentation) Using the "leftbar" facility on CMS twiki pages: WorkBookContributors#CMS.LeftBar

LFN (Logical File Name)

(computing) a site-independent name for a file. WorkBookDataSamples#LfN

LHC

Large Hadron Collider. See a timeline of possible developments in CERN Bulletin

LHCb

Large Hadron Collider beauty experiment

LHCC

(organisation) LHC experiment Committee

LHE

Les Houches events - samples made with matrix element generators (madgraph, Sherpa, Alpgen,...) where the generation is done in a separate step using the Les Houches convention

LHeC

Large Hadron-Electron Collider, a project aiming at collisions after ~2020 of 7 TeV protons/nucleons from HL-LHC with electrons from a new e-machine with the energy of ~50 GeV (e-ring option) or ~70 GeV (e-linac option), see a timeline in CERN Bulletin

LINAC2

CERN LInear hadron accelerator, provides 50 MeV Protons

Linux commands

WorkBookBasicLinux#BasicLinux

Logging in

• Logging in to the CERN Unix cluster: WorkBookSetComputerNode#LogIn
• Summary of steps for every login session: WorkBookSetComputerNode#StepSummary

Logical File Name (LFN)

see entry for LFN

LS

Lumi Sections

LS1

LHC Long Shutdown 1 -- up to 19? months in 2013-2014

LS2

LHC Long Shutdown 2 -- year 2018?

LS3

LHC Long Shutdown 3 -- year 2022?

LSB

(computing) Least Significant Bit

LSF

(computing) Load Sharing Facility (Batch system)

LSO

(safety) Laser Safety Officer

LTC

(Trigger) Local Trigger Control

LTEX

LHC Tunnel and Experiments Study Group: meetings

LUMI

(detector) luminosity. Reference: CMS.LumiWikiHome

LUT

(software) Look-Up Table

Lumi section

Sub-section of a run during which time the instantaneous Luminosity is unchanging. Initially this was defined as 2^20 orbits ~ 93 seconds; it was later redefined to be 2^18 orbits ~ 23.3 seconds. Unit of accounting for integrated luminosity. Production data files will contain one or many whole luminosity sections.

LV

(general) Low Voltage

LVPS

Low Voltage Power Supply

LXR

(computing/documentation) Linux Cross Reference. Used, for example, to produce a cross-referenced display of the CMS source code. References: WorkBookHelp#LxR, http://cmslxr.fnal.gov.lxr

M

M&O

(organisation) Maintenance and Operation

M&O-A

(organisation) Maintenance and Operation Funds, category A (contributed by Funding Agencies to the experiment)

M&O-B

(organisation) Maintenance and Operation Funds, category B (contributed by Funding Agencies to individual sub-detector projects)

MAB (Module pour Alignement de Barril)

Carbon-fibre structures where videocameras (on some of them ASPDs and DCOPs, too) are installed in order to be able to perform the hardware alignment of the DT chambers. There are 36 such modules installed on the CMS Barrel.

MAD

(safety) Material Access Device

MadEvent

the program produced by MadGraph to integrate the cross-section of the given process and produce unweighted events in the Les Houches format. Reference: SWGuideMadGraphInterface

MadGraph

a matrix element generator that generates amplitudes for relevant subprocesses of specified particle physics interactions. Reference: SWGuideMadGraphInterface

MadGraphInterface

SWGuideMadGraphInterface

Mailing Lists

WorkBookHelp#MailingLists

MAO

(detector) CAEN A3486 ACDC power converter (380V 3-phase to 48V dc) are also called MAOs. This name has been given by the CAEN engineers.

Maraton

Low voltage for the CSCs and peripheral crates is supplied by a MARATON power supply, which provides two lines to the CSC's junction box: 6 V DC and 7 V DC, and two lines to the peripheral crates: 4.5 V DC at 40 A and 6.5 V DC at 10 A.

MB

Minimum Bias

MB

(organisation) Management Board

MBUE

Minimum Bias Underlying Event

MC

(computing/general) Monte Carlo simulation

MCS

(safety) Magnet Control System

MD

(LHC) Machine Development

ME

Prefix designating the Muon End Cap sub-system, EMU, CSC

Meeting Agendas

(organisation) [WorkBookHelp#AgendaM]]

Meetings

WorkBookHelp#MeetingS

Message Logger

WorkBookSimDigi#ConfigOutput

MET

(physics) Missing Transverse Energy

MIP

(detector) Minimum Ionising Particle

Minicrate

(detector) DT on-detector electronics (one minicrate per DT chamber hosts front-end, readout and trigger electronics)

MMM - My Mail and More

WorkBookHelp#MmM

MoA

(organisation) Memorandum of Agreement, the document describing the service work obligations of Institutes and Members toward the experiment

MOF-A

(organisation) Maintenance and Operation Funds, category A (contributed by Funding Agencies to the experiment)

MOF-B

(organisation) Maintenance and Operation Funds, category B (contributed by Funding Agencies to individual sub-detector projects)

Module

An event-processing element, a plugin (C++ class) to the CMSSW executable. All modules derive from one of the three worker base classes: EDProducer, EDFilter or EDAnalyzer.

Module Label

In CMSSW, a "human friendly" string that acts as a unique identifier (within a job) used for EDProducts created by the module configured by this label. Changing this label within a job will spawn a new module.

Monte Carlo Generators

see entry for event generation

MoU

Memorandum of Understanding

MPC

Muon Port Card, CSC peripheral crate electronics board, 1 per pcrate

MPI

(physics) Multiple Parton Interactions (in hadron-hadron and other collisions)

MRH

(calibration) Multi-Run Harvesting

MSS

(safety) Magnet Safety System

MSSM

Minimal SuperSymetric Model

MTCC

(experiment) Magnet Test and Cosmic Challenge. References: CMS.CMSComputingForMTCC , CMS NOTE 2007/005

MVA

(analysis) Multivariate Data Analysis

MWGR

middle week global run

N

NEG

Non-Evaporable Getter -- a powder used in NEG pumps;
also an abbreviation for a NEG pump

NGI National Grid Initiative

a project in one or few single countries to run a computing grid infrastructure

NICE

cern.ch email system. This password is used across several CERN computing. NICE Services.

O

O&C

(organisation) Offline and Computing

ODH

(safety) Oxygen Deficiency Hazard

Online WorkBook

CMS Online/Shifter's WorkBook: CMS.MtccWB

OMDS

(databases) Online Master Data Storage

OMS

Online Monitoring Service

OO

Object Oriented (Software)

OPFC

Power Factor Corrector module, part of the Maraton LVPS system

ORCA

deprecated CMS software for digitisation of simulated electronics response (for Monte Carlo events) and reconstruction and analysis (for real and MC events)

ORCON

(databases) Offline Reconstruction Conditions DB at Online, used by CMSSW applications at P5 (HLT, DQM)

ORCOFF

(databases) Offline Reconstruction Conditions DB at Offline, used by CMSSW applications outside P5

ORM

Offline Run Manager

OS

Operating System

OS

(physics) Oppositely-Signed (physics objects of opposite electric charge)

OSCAR

deprecated CMS software for running generation and GEANT4 detector simulation of Monte Carlo events

OSG

(grid) Open Science Grid

Output Module

Reads data from the Event, and once all paths have been executed, stores the output to external media. An example is PoolOutputModule, which writes data to a standard CMS format ROOT file

O2O

Online-to-Offline

P

PA

CMS.ProdAgent, a tool for submitting jobs for large mass production.

PACE

Preshower Analogue CMS Electronics - the front-end chip designed for the CMS Preshower project. It comprises two separate chips: Delta (a 32-channel pre-amp and switchable-gain shaper) and PACE-AM (32 channel, 192-cell deep analogue memory with multiplexed output of 3 consecutive cells for every level-1 trigger received)

PAD

(safety) Personnel Access Devise

PADA

(computing) Processing And Data Access Task Force

PADC

(detector) Pressure ADC board

PAG

(organisation) Physics Analysis Group

Parameter Set

A collection of name/value pairs used to configure an element in a framework application.

Parentage

In CMSSW, a vector of the unique identifiers of the EDProducts used as inputs for this bit of reconstruction.

Particle Candidates

• Combiners: WorkBookParticleCandidates#CandComb
• Information: WorkBookParticleCandidates
• Selectors: WorkBookParticleCandidates#CandSel

Particle gun (simulations)

WorkBookGeneration#SampleConfig

PAS

(analysis) Physics Analysis Summary, a public list of CMS PASes

PAT

(analysis) Physics Analysis Toolkit WorkBookPAT

PAT Glossary

(analysis) Glossary of commonly used PAT expressions WorkBookPATGlossary

Path

The user's expression of requirements regarding which modules (including their configurations) make up a single high-level trigger. (Also a listing of directory areas that the system should search to find user executables and files.)

PAW

Physics Analysis Workstation (Fortran-based legacy data analysis package)

PBS

Portable Batch System

PC

Publication Committee

PCL

(calibration) Prompt Calibration Loop

PCMB

Peripheral Crate Monitor Board - plugs into the CSC system pcrate CRB

pcrate

Peripheral Crate, CSC off-chamber front end electronics crate

PD or PDS

(data) Primary Data Sets

PdmV

(organisation) Physics Data/MC Validation -- a group within the PPD Project

People Search

WorkBookHelp#SearcHingCERN

peripheral crate

CSC off-chamber front end electronics crate

PF

(physics) Particle Flow algorithm (algorithm for identification of hadronically decaying taus on the level of individual and unique particles)

PFG

prompt feedback group

PFN

Physical File Name: site-dependent name for a file. Reference: WorkBookDataSamples#PfN

PG

(detector) Power Group

PhEDEx

Physics Experiment Data Export (data transfer and placement system) - moves data around CMS. Reference: CMS.PhEDEx

Phone conferences

WorkBookHelp#PhoneConf

Phone numbers search

CERN phone directory: WorkBookHelp#SearcHingCERN

Photos

CERN/CMS etc pictures and photos: WorkBookHelp#ImaGes

Physical File Name (PFN)

site-dependent name for a file: WorkBookDataSamples#PfN

Pictures

CERN/CMS etc pictures and photos: WorkBookHelp#ImaGes

Pile-up (PU)

Pile-up occurs when the readout of a particle detector includes information from more than one event. This specifically refers to cases where there are other (background) collisions somewhere within a timing window around the signal collision.

PInG

(organisation) Physics Interest Group, within the Heavy-Ion PAG

PLL

a circuit generating an output clock whose frequency is the same of an input "reference" clock and its phase is related to the reference clock phase

PLT

(detector) Pixel Luminosity Telescope; part of the BRIL sub-system.

PMT

Photo multiplier tube

PN (as in ECAL PN)

PIN Diode

POG

(organisation) Physics Object Group

POPULARITY SERVICE

Popularity of the DataTier in terms of # Accesses, CPU time and Users*day, in a specific time window - popularity

POOL

(data) Pool Of persistent Objects for Lhc (Data management) implements a common persistency framework for the LHC Computing Grid (LCG) application area. POOL can store multi-Petabyte experiment data and metadata in a distributed and grid enabled way, providing navigational access to distributed data without exposing details of the particular storage technology. Reference: http://pool.cern.ch/

PPD

(organisation) Physics Performance & Dataset Project (home page)

PPS

(detector) Precision Proton Spectrometer. Reference: https://cds.cern.ch/record/1753795

Preselection

??

Printing WorkBook pages and chapters

WorkBookPrintable

Provenance (of a CMSSW EDProduct)

Collectively, the information that allows users to unambiguously identify how each reconstruction result was produced. Each EDProduct is associated with a provenance object that records this information. Also see WorkBookMoreOnCMSSWFramework

PFN

Physical File Name - site-dependent name for a file.

PKAM

'Previously Known As Monsters': Events with exceptionally high occupancy in the pixel detector (see this link for the acronym definition).

PRS

(organisation) (deprecated) Physics Reconstruction and Selection organisational structure - PRS is split into two top-level groups covering the detector and analysis

Pset

(software) Parameter Set

PSC

(detector) Power Supply Controller

PSI

PVSS SOAP Interface

PSU

(detector) Power Supply Unit

PTC

(trigger) Partition Controler

PU

Pile-up

PVSS

(software) Prozessvisualisierungs- und Steuerungssystem (Process visualization and control system)

PV

(physics) Primary Vertex (i.e. the interaction point)

PVT

Physics Validation Team

PYTHIA Event Generator

(computing) A program for generation of high-energy physics events. Reference: WorkBookGeneration#PythiA

Python

(programming) An interpreted, interactive, object-oriented, open-source programming languange

Q

QCD

(physics) Quantum Chromo-Dynamics

QED

(physics) Quantum Electro-Dynamics

QF

Quality Flag

QIE

HCAL charge integrator and encoder

QPLL

(detector) a Quartz crystal based Phase-Locked Loop. The device function is to act as a jitter-filter for clock signals operating synchronously with the LHC bunch-crossing clock. See QPLL home page

QWG

Quarkonium Working Group

R

RA

(physics) Reference Analysis groups (may be SUSY specific)

RAMSES

(safety) RAdiation Monitoring System for the Environment and Safety

RAW

(data) Raw Data event format. Reference: WorkBookDataFormats#EvenT

RB

Resource Broker (Grid)

RBX

Readout BoX

RC

Replica Catalog (Grid)

RCMS

Run Control and Monitoring System

RCT

Regional Calorimeter Trigger (part of the L1 trigger). Reference: SWguideRegionalCaloTrigger

RDBMS

Relation Database Management System

RECO

Data after reconstruction. RECO is a CMSSW Data Format containing the relevant output of reconstruction. It is derived from RAW data and provides access to reconstructed physics objects for physics analysis in a convenient format. (more information: WorkBookDataFormats#RecO, SWGuideRecoDataFormat, REO)

Reconstructed data

see entry for RECO

Reconstructor

A module whose primary purpose is to perform some step of reconstruction and to place the result into the Event.

Reference Manual

Generated by DoxyGeN (not part of the CMS Offline WorkBook): http://cmsdoc.cern.ch/Releases/CMSSW/latest_nightly/doc/html/

Release Validation Samples

(analysis) WorkBookDataSamples#RvS

Remote Site

(computing/infrastructure) Working from computer sites outside CERN: WorkBookRemoteSiteSpecifics

REX

(safety) Retour d'EXperience (lessons learnt)

RF

Radiofrequency

RF2TTC

Radio-Frequency (group) to Trigger Timing and Control format conversion

RFIO

(computing) Remote File I/O

RFM

Run Field Manager

RFRXD

RFRX (or maybe better RFRx), means it's a Radio-Frequency receiver (RX=receiver). The second part, the D, means the digital version of the board (i.e. the second generation, the fist was analog)

RHEL

(computing) Redhat Enterprise Linux

RLS

(grid) Replica Location Service

RIO

(analysis) Reconstruction Input Object

ROB

(computing) Read-Out Buffer

ROC

(experiment) Read-Out Chip

ROC

Remote Operations Center at FNAL

ROD

(computing) Read-Out Driver

RoI

(analysis) Region of Interest

RooStats

(analysis) a project to create statistical tools built on top of RooFit and distributed in ROOT. It is a joint project between the LHC experiments and the ROOT team. Reference: https://twiki.cern.ch/twiki/bin/view/RooStats/WebHome

RooStatsCms

(analysis) a CMS-specific extension to the RooStats project. Reference: SWGuideRooStatsCms

ROOT

(computing/analysis) A class library / application for data analysis. Reference: WorkBookBasicROOT

RP

(experiment) Roman Pot: movable beam-pipe insertion dedicated to host detectors for measuring protons scattered to very small angles

RPC

(experiment) Resistive Plate Chamber

RPE

(safety) RadioProtection Expert

RR

(computing) Run Registry

RRB

(organisation) Resources Review Board

RS

(physics) Randall-Sundrum: RS model, RS graviton

RSL

(grid) Resource Specification Language

RSO

(safety) Radiation Safety Officer

RTAG

(grid) Requirements Technical Assessment Group (LCG)

RU

(DAQ) Readout Unit

S

SC

(data) Super Cluster

SCA

(detector) Switched Capacitor Array (in CSC front-end readout electronics)

SCAL

(detector) The online Scalers subsystem provides a way to introduce asynchronous data into the synchronous CMS data acquistion stream. The data injected into the data stream are: Level 1 Gobal Trigger counters, Luminosity counters, DCS subsystem voltage status, magnet currrent and temperature, and the synchronous history of the prior four L1 accept bunch crossing and orbit numbers. The CMSSW package DataFormats/Scalers has DIGI class files produced by the SCAL. SCAL also provides a number of monitoring and recording functions, such as writing Trigger and Luminosity rates into the online database, and receiving and recording LHC state changes through an LHC GMT (General Machine Timing) serial cable interface (see CmsLhcGmt for details). SCAL detects such events as the beginning and ending of LHC fills and records them as such in the Run Time Logger database; to assist in operational efficiency calculations, SCAL detects the absence of L1 triggers in excess of 93 seconds and records downtime in the same database.

Scheduled Application

In CMSSW, a style of application that is similar to the CDF and D0 trigger and reconstruction frameworks; more "linear" than the scheduled style. A scheduled application is configured by specifying a module instance path through which the event will flow.

ScheduleBuilder

schedules a set of modules for execution

ScheduleExecutor

invokes modules

SCR

(safety) Safety Control Room (Fire Brigade (FB), on the Meyrin site, b. 65)

SCRAM

Source Configuration, Release, And Management: a software tool responsible for building framework applications and also making sure that all the necessary shared libraries are available. Reference: WorkBookScramV1Intro

SCT

Semiconductor Tracker (Inner Detector)

SCX

(safety) Surface Control eXperiment building

SD

(physics) Single Diffractive events; (CMSSW) Secondary Dataset

SDP

Software Development Process

SDPV

Software Detector Physics Validation

SDO

Simulation Data Objects

SE

Storage Element (Grid)

SEAL

The Shared Environment for Applications at LHC, which provides common core and services (such as system, utility, framework, and mathematics) libraries for LCG applications in order to improve their coherency. Refer to the project seal for documentation, releases, and other details. Workbook reference: SWGuideDeclarePlugins

Searching

Searching for info at CERN (keywords, people, phone numbers, buildings, ...): WorkBookHelp#SearcHingCERN

Segment (in the muon chamber)

linear fit of the hits within a single chamber. It is the basic brick for the STA and TM building.

Selector

A predicate used to identify interesting EDProducts. It does so by examining the Provenance associated with that EDProduct. It encapsulates the user's requirements (i.e., features of interest) for products.

SEU

(detector) Single Event Upset -- (?) a failure of electronics induced by a single particle interaction

SGE

Sun Grid Engine (Batch Job System)

Shifter's WorkBook

see entry for Online WorkBook

SI2K

SpecInt2000 (CPU Benchmark)

SIM

Simulated Data (RAW Format)/SIMulated hits. Reference:WorkBookDataFormats

Simulation

Detector Simulation: WorkBookSimDigi#DetSim

Simulator (detector simulation of generated events)

The CMSSW simulation code, based on Geant4 concepts, is configured with CMS-specific information as to the detector geometry and materials, and knowledge of how various particles of given characteristics interact with the materials. The simulator takes input from a generated event, processes it, and writes back to the event a new (hit) container for each subdetector. In each of these containers it writes the position and energy of the virtual hits as seen by that subdetector.

SiPM

silicon photomultiplier (also called GAPD)

SLB

Synchronization and Link Board

SLC3

Scientific Linux CERN 3 operating system

SLC5

Scientific Linux CERN 5 operating system

SLIMOS

(safety) Shift Leader In Matters of Safety

SLHC

(detector) Super LHC

S-LINK

simple link interface developed at CERN

S-LINK64

64 bit S-LINK used in CMS

skimming

running selection criteria over a collection of events and writing only selected events to a new, and therefore smaller, file. This is used to speed up analysis jobs by producing a smaller sample of more-likely useful events to run over.

SM

(physics) Standard Model

SM

(data) Storage Manager

SMP PAG

Standard Model Physics Analysis Group

SMPS

(data) Storage Manager Proxy Server

soup

mixtures of different physics processes in a simulated event sample

Source (for Event Generation)

A source is a module that can put generated data into an event in memory from where other modules can access it on-the-fly. There are generator sources (e.g. Pythia or single particle gun) and input sources that recreate the event in memory from its ROOT file.

Source Configuration, Release And Management tool (SCRAM)

WorkBookScramV1Intro

Source Module

Reads in an Event from a ROOT file or generates an Event for Monte Carlo, gives the Event status information (such as Event number), and can add data directly or set up a call-back system to retrieve the data on the first request. Examples include the DaqSource, which reads in Events from the global DAQ, and the PoolSource, which reads Events from a ROOT file.

Spigot

(detector) One of 15 input sockets on an HCAL DCC. Commuicates to one Half-HTR.

SRM

Storage Resource Manager (Grid)

SS

(physics) Same-Signed (physics objects of same electric charge)

STA

Stand alone muon. Track fit in the muon chambers. It involves more than a chamber at a time.

Statistics committee

(data analysis) forms recommendations on statistical issues identified in CMS physics analyses, etc. see StatisticsCommittee

STL

Standard Template Library (C++)

Summary

summary of changes to WorkBook pages: WorkBookSummary

SUSY

(physics) Super Symmetry

SVS

Software Validation Suite (SDP Validation)

SVX

Secondary Vertex

T

TAG

Event-level metadata. Very brief event summary data. Reference: WorkBookDataFormats#EvenT

TaNC

(physics) Tau Neural Classifier (neural net algorithm for reconstructing hadronically decaying taus)

TB

Generally refers to Test Beam

TC

• (software) Tag Collector
• Technical Coordinator

TCC

Trigger Concentrator Card (detector ECAL) - VME modules that generate the ECAL Trigger Primitives in conjunction with the ECAL Front-End boards. They come in two flavors ie EBTCC (or TCC68, this type has 68 inputs) for the barrel part or EETCC (or TCC48, this type has 48 inputs) for the endcap parts. There are 36 EBTCC and 72 EETCC installed in the ECAL Off Detector Electronics crates.

TCDS

Timing and Control Distribution System

TCP/IP

network Transmission Control Protocol / Internet Protocol

TCS

Trigger Control System

TDC

Time to Digital Converter - a very fast timer

TDPC

(safety) Total Discharge with the Power Converter (inverter mode, current ramped down to zero)

TDR

(documents) Technical Design Report

TGC

Triple Gauge Couplings

TEC

(detector) CMS Tracker End Cap

Telephone conferences

WorkBookHelp#PhoneConf

TFB

Tracker Finance Board

TFC

(detector)

TIB

(detector) CMS Tracker Inner Barrel

TIB

Tracker Institution Board

TID

(detector) Tracker Inner Disks

Tiered Architecture

(computing/infrastructure) The structure used by the computing centres used by CMS around the world. The tiered architecture functions as a single coherent system with three levels that provide different resources and services. Reference: WorkBookComputingModel#TieRs

Tier0 Computing Centre

(computing/infrastructure) This is the first computing tier of the CMS model, and is based at CERN. It deals with raw data - storage, analysis, processing. It runs prompt reconstruction, classifies data into ~50 event streams, and distributes the data among tier 1 sites. Reference: WorkBookComputingModel#TierZero

Tier1 Computing Centre

(computing/infrastructure) Major computing sites that have custodial responsibility for a defined part of the data. Tier1s provide substantial CPU power for re-reconstruction, skimming, calibration and other data-intensive analysis tasks. It also distributes reconstructed data sets to its associated Tier 2 sites. Reference: WorkBookComputingModel#TierOne

Tier2 Computing Centre

(computing/infrastructure) Smaller computing centres with substantial CPU resources that are available for user analysis, calibration studies and Monte Carlo production. They obtain real data from Tier1 sites, and send generated Monte Carlo samples to Tier1s for secure storage. Reference: WorkBookComputingModel#TierTwo

TK

(detector) CMS tracking system

TM

Tracker muon. Track in the tracker with matched segments in the muon system (the so-called inside-out approach).

TMB

Trigger Mother Board, CSC peripheral crate electronics board, 9 per pcrate

TMI

(organisation / trigger) Trigger Menu Integration group within the Trigger Studies Group (TSG). А.k.a. the Online Operations group. Since the beginning of Run 2 it has been superseded by FOG.

TOB

(detector) CMS Tracker Outer Barrel

TOF

(physics/detector) Time Of Flight

TOTEM

(physics/detector) TOTal Elastic and diffractive cross section Measurement - TOTEM Experiment. TOTEM has been installed near the point where protons collide in the center of the CMS detector. It will complement the results obtained by the CMS detector and uses 'Roman pots'.

TP

(detector) Trigger Primitive

TPG

(detector) Trigger Primitive Generator

TPO

Tracker Project Office

TPS

Trigger Performance and Strategy Working Group, aiming at the development of long-range strategies for the CMS Upgrade Program in triggering (concept Mar 2012)

Trac

Trac is a part of CERN Central SVN Service

Track Reconstruction

WorkBookTrackAnalysis

TriDAS

(trigger) Trigger and Data Acquisition System: the trigger task is to select the most interesting events. Reference: CMS.TriDASWikiHome The first level trigger is the hardware trigger, which reduces the event rate from 40 Mhz to O(100)kHz. The subsequent HLT further selects events to yield an output rate of a O(100)Hz. The TriDAS makes events available to the offline Tier0 Centre. See also: WorkBookHLTTutorial

Trg

Trigger

Trigger

Trigger is combination of hardware and software system that uses certain criteria (based on physics algorithms) to rapidly decide to keep(record) or drop a proton-proton collision event in the CMS detector. Each physics group (SUSY, Higgs, Exotica etc. ) would like to trigger on events interesting to their physics hence leading to different trigger paths. $ Trigger path: A trigger path is a sequence of CMSSW modules which ultimately makes a boolean decision to keep or drop an event. Also see definition of a Trigger.

TRK

tracker

Troubleshooting

WorkBookTroubleShooting

TS

(LHC) Technical Stop

TSG

(trigger) Trigger Studies Group

TTC

(detector) Trigger Timing and Control

TTCci

(detector) TTC CMS interface

TTCex

(detector) TTC encoder/transmitter

TTS

Trigger Throttle System

TUPO

Tracker Upgrade Project Office

TURL

(grid) Transfer URL

TUSC

Tracker Upgrade Steering Committee

Twiki

• CMS Twiki Policy: CMSTwikiPolicy
• General information: WorkBookHelp#TheTwiKi
• Formatting rules: https://twiki.cern.ch/twiki/bin/view/TWiki/TextFormattingRules

U

UE

Underlying Event

Unscheduled Application

In CMSSW, a style of application that supports reconstruction on demand. An unscheduled application may be configured in a few ways: selecting top-level EDProducers, high level triggers, an analysis module, or some combination of these.

UI

User Interface: grid, computing

URL

Universal Resource Locator (Web or Grid)

USC55

(safety) Underground Service Cavern at LHC Point 5

User Support and help

(computing) http://cms.cern.ch/iCMS/jsp/page.jsp?mode=cms&action=url&urlkey=CMS_US

User's Office FAQ

(general) http://ph-dep-usersoffice.web.cern.ch/ph-dep-UsersOffice/FAQ%27s.html

UXC55

(safety) Underground eXperimental Cavern at LHC Point 5

V

VBF

(physics) Vector Boson Fusion

VCC

VME Crate Controller - CSC peripheral crate electronics board, 1 per pcrate

VDC

(detector) Velocity Drift Chamber

VDT

(software) Virtual Data Toolkit. Reference: http://vdt.cs.wisc.edu/

Victor

- Site Cleaning Monitoring interface - Victor

Vis (.vis file extension)

This is the file extension of the FROG file containing events data.

Visualisation

The CMS Event Display is IGUANACMS: WorkBookEventDisplay

VME

Versa Module Europa bus

VO

Virtual Organization (Grid)

VOMS

Virtual Organization Membership Service (Grid)

VOMRS Virtual Organization Memebership Registration Service (Grid)

an interface to VOMS to manage applications by VO members

VPT

(detector) Vacuum Phototriode - A single stage, magnetic field tolerant phototube, deployed in the endcaps of the ECAL

VRVS

(deprecated) Virtual Room Video Conference System - internet-based meeting tool. See also entry for EVO. Reference: WorkBookHelp#EvO

W

WAN

Wide Area Network

WBS

(planning) Work Breakdown Structure

WBM

CMS Online Web Based Monitoring is a suite of web based tools used for monitoring the online real-time and historical status of the CMS detector, trigger, and data acquisition. See the WBM link at http://cern.ch/cmswbm or at http://cmswbm.cms if you are inside the P5 network.

Web pages

Useful CERN/CMS web pages: WorkBookHelp#MainWeb

WGM

Weekly General Meeting. See the list of WGMs in Indico .

WIMP

(physics) weakly interacting massive particle, wikipedia

WLCG

Worldwide LHC Computing Grid project: WorkBookStartingGrid#LcG

WMS

Work Management System (Grid) - manages remote jobs

WN

Worker Node (Grid)

WMAgent

collection of libraries and components that provide a grid workload management system. It is written in python and interacts with multiple grid systems. WMAgent

X

XDAQ

the CMS Online software platform -- a software platform designed for the development of distributed data acquisition systems. See project page .

XC

(meeting) Cross Coordination

XEB

Extended Executive Board

XMAS

XDAQ Monitoring and Alarming System

XML

Extensible Markup Language

xyz-coordinates

(CMSConventions) Axes according to CMS IN 2000/054: X points towards the center of LHC ring, Y -- upwards, Z = X × Y

Y

YB

(detector) Yoke Barrel

YETS

Year-End Technical Stop

Z

ZDC

(detector) Zero Degree Calorimeter. Reference: CMS.ZDCWikiHome

ZEBRA

Legacy data management system

-- LucasTaylor - 27 Nov 2006 (reviewed and revised complete glossary)
-- JennyWilliams - 23 Nov 2007 (combined with WorkBook Index and CMSAcronyms and deleted index)

Responsible: KatiLassilaPerini and SudhirMalik
Last reviewed by: LucasTaylor - 27 Nov 2006