Update CMSSW exercise and analysis files; correct paths and add new scripts

Author: alefisico

episodes/02-cmsswexercise.md

@@ -118,7 +118,7 @@ Copy the analysis code into your CMSSW work area:
 ```bash
 cd ${CMSSW_BASE}/src/
 mkdir -p AnalysisCode
-cp -r ~/cmsdas/cmsdas-gitlab-cms/ZPeakAnalysis AnalysisCode/
+cp -r ~/cmsdas/cmsdas/cmsdas-gitlab-cms/ZPeakAnalysis AnalysisCode/
 ```
 
 Now your code is in the right place for CMSSW to find and compile it.

episodes/04-gitlabci-run-analysis.md

@@ -113,7 +113,7 @@ cmssw_compile:
     - cmsenv
     - mkdir -p AnalysisCode
     - cp -r $CI_PROJECT_DIR/ZPeakAnalysis AnalysisCode/
-    - cd ${CMSSW_RELEASE}/src
+    - cd ${CMSSW_BASE}/src
     - scram b -j 4
   artifacts:
     untracked: true

episodes/files/ZPeakAnalysis.zip

@@ -0,0 +1,4 @@
+<use name="root"/>
+<export>
+  <lib   name="1"/>
+</export>

episodes/files/ZPeakAnalysis/BuildFile.xml

@@ -0,0 +1,7 @@
+<use   name="FWCore/Framework"/>
+<use   name="FWCore/ParameterSet"/>
+<use   name="FWCore/ServiceRegistry"/>
+<use   name="PhysicsTools/UtilAlgos"/>
+<library   file="*.cc" name="AnalysisCodeZPeakAnalysisPlugins">
+  <flags   EDM_PLUGIN="1"/>
+</library>

episodes/files/ZPeakAnalysis/plugins/BuildFile.xml

@@ -0,0 +1,135 @@
+#include <map>
+#include <string>
+
+#include "TH1.h"
+
+#include "FWCore/Framework/interface/Frameworkfwd.h"
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/EDAnalyzer.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/ServiceRegistry/interface/Service.h"
+#include "CommonTools/UtilAlgos/interface/TFileService.h"
+#include "DataFormats/PatCandidates/interface/Muon.h"
+
+#include "DataFormats/PatCandidates/interface/Electron.h"
+#include "DataFormats/PatCandidates/interface/Muon.h"
+
+class MyZPeakAnalyzer : public edm::EDAnalyzer {
+
+public:
+   explicit MyZPeakAnalyzer(const edm::ParameterSet&);
+   ~MyZPeakAnalyzer();
+
+private:
+
+   virtual void beginJob() ;
+   virtual void analyze(const edm::Event&, const edm::EventSetup&);
+   virtual void endJob() ;
+
+   // simple map to contain all histograms;
+   // histograms are booked in the beginJob()
+   // method
+   std::map<std::string,TH1F*> histContainer_;
+   // ----------member data ---------------------------
+   edm::EDGetTokenT<pat::MuonCollection> muonCollToken;
+   edm::EDGetTokenT<pat::ElectronCollection> elecCollToken;
+
+   // input tags
+   edm::InputTag muonSrc_;
+   edm::InputTag elecSrc_;
+};
+
+
+MyZPeakAnalyzer::MyZPeakAnalyzer(const edm::ParameterSet& iConfig):
+
+   histContainer_(),
+   muonSrc_(iConfig.getUntrackedParameter<edm::InputTag>("muonSrc")),
+   elecSrc_(iConfig.getUntrackedParameter<edm::InputTag>("elecSrc")){
+
+   muonCollToken = consumes<pat::MuonCollection>(muonSrc_);
+   elecCollToken = consumes<pat::ElectronCollection>(elecSrc_);
+
+}
+
+MyZPeakAnalyzer::~MyZPeakAnalyzer(){
+}
+
+void
+MyZPeakAnalyzer::analyze(const edm::Event& iEvent,
+                         const edm::EventSetup& iSetup){
+
+   // get pat muon collection
+   edm::Handle< std::vector<pat::Muon>> muons;
+   iEvent.getByToken(muonCollToken, muons);
+
+   // fill pat muon histograms
+   for (auto it = muons->cbegin(); it != muons->cend(); ++it) {
+      histContainer_["muonPt"] ->Fill(it->pt());
+      histContainer_["muonEta"]->Fill(it->eta());
+      histContainer_["muonPhi"]->Fill(it->phi());
+
+      if( it->pt()>20 && fabs(it->eta())<2.1 ){
+         for (auto it2 = muons->cbegin(); it2 != muons->cend(); ++it2){
+            if (it2 > it){
+               // check only muon pairs of unequal charge
+               if( it->charge()*it2->charge()<0){
+                  histContainer_["mumuMass"]->Fill((it->p4()+it2->p4()).mass());
+               }
+            }
+         }
+      }
+   }
+
+   // get pat electron collection
+   edm::Handle< std::vector<pat::Electron>> electrons;
+   iEvent.getByToken(elecCollToken, electrons);
+
+   // loop over electrons
+   for (auto it = electrons->cbegin(); it != electrons->cend(); ++it) {
+      histContainer_["elePt"] ->Fill(it->pt());
+      histContainer_["eleEta"]->Fill(it->eta());
+      histContainer_["elePhi"]->Fill(it->phi());
+   }
+
+   // Multiplicity
+   histContainer_["eleMult" ]->Fill(electrons->size());
+   histContainer_["muonMult"]->Fill(muons->size() );
+}
+
+void
+MyZPeakAnalyzer::beginJob()
+{
+   // register to the TFileService
+   edm::Service<TFileService> fs;
+
+
+   histContainer_["mumuMass"]=fs->make<TH1F>("mumuMass", "mass",    90,   30., 120.);
+
+   // book histograms for Multiplicity:
+
+   histContainer_["eleMult"]=fs->make<TH1F>("eleMult",   "electron multiplicity", 100, 0,  50);
+   histContainer_["muonMult"]=fs->make<TH1F>("muonMult",   "muon multiplicity",     100, 0,  50);
+
+   // book histograms for Pt:
+
+   histContainer_["elePt"]=fs->make<TH1F>("elePt",   "electron Pt", 100, 0,  200);
+   histContainer_["muonPt"]=fs->make<TH1F>("muonPt",   "muon Pt", 100, 0, 200);
+
+   // book histograms for Eta:
+   histContainer_["eleEta"]=fs->make<TH1F>("eleEta",   "electron Eta",100, -5,  5);
+   histContainer_["muonEta"]=fs->make<TH1F>("muonEta",   "muon Eta",  100, -5,  5);
+
+
+   // book histograms for Phi:
+   histContainer_["elePhi"]=fs->make<TH1F>("elePhi",   "electron Phi", 100, -3.5, 3.5);
+   histContainer_["muonPhi"]=fs->make<TH1F>("muonPhi",   "muon Phi",     100, -3.5, 3.5);
+
+}
+
+void
+MyZPeakAnalyzer::endJob()
+{
+}
+
+#include "FWCore/Framework/interface/MakerMacros.h"
+DEFINE_FWK_MODULE(MyZPeakAnalyzer);

episodes/files/ZPeakAnalysis/plugins/MyZPeakAnalyzer.cc

@@ -0,0 +1,26 @@
+import FWCore.ParameterSet.Config as cms
+from FWCore.ParameterSet.VarParsing import VarParsing
+
+options = VarParsing ('analysis')
+
+process = cms.Process("Test")
+
+process.source = cms.Source("PoolSource",
+  fileNames = cms.untracked.vstring (options.inputFiles)
+)
+
+process.MessageLogger = cms.Service("MessageLogger")
+process.maxEvents = cms.untracked.PSet(
+  input = cms.untracked.int32(10000)
+)
+
+process.analyzeBasicPat = cms.EDAnalyzer("MyZPeakAnalyzer",
+  muonSrc = cms.untracked.InputTag("slimmedMuons"),
+  elecSrc = cms.untracked.InputTag("slimmedElectrons"),
+)
+
+process.TFileService = cms.Service("TFileService",
+                                   fileName = cms.string('myZPeak.root')
+                                   )
+
+process.p = cms.Path(process.analyzeBasicPat)

episodes/files/ZPeakAnalysis/test/MyZPeak_cfg.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+import sys
+import argparse
+
+def parse_integral_file(filename):
+    """Parses the text file and returns a dictionary of {variable: value}."""
+    data = {}
+    try:
+        with open(filename, 'r') as f:
+            for line in f:
+                if ':' in line:
+                    parts = line.split(':')
+                    key = parts[0].replace('Integral of ', '').strip()
+                    value = float(parts[1].strip())
+                    data[key] = value
+        return data
+    except FileNotFoundError:
+        print(f"Error: File '{filename}' not found.")
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error parsing '{filename}': {e}")
+        sys.exit(1)
+
+def compare(file1, file2, tolerance=1e-6):
+    data1 = parse_integral_file(file1)
+    data2 = parse_integral_file(file2)
+
+    all_keys = set(data1.keys()).union(set(data2.keys()))
+    match = True
+
+    print(f"{'Variable':<20} | {'File 1':<15} | {'File 2':<15} | {'Status'}")
+    print("-" * 70)
+
+    for key in sorted(all_keys):
+        val1 = data1.get(key, None)
+        val2 = data2.get(key, None)
+
+        if val1 is None or val2 is None:
+            status = "MISSING"
+            match = False
+        elif abs(val1 - val2) <= tolerance:
+            status = "PASS"
+        else:
+            status = "FAIL"
+            match = False
+
+        print(f"{key:<20} | {str(val1):<15} | {str(val2):<15} | {status}")
+
+    return match
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Compare CMSSW integral outputs.")
+    parser.add_argument("file1", help="First txt file (reference)")
+    parser.add_argument("file2", help="Second txt file (new run)")
+    args = parser.parse_args()
+
+    if compare(args.file1, args.file2):
+        print("\nSUCCESS: The files match.")
+        sys.exit(0)
+    else:
+        print("\nFAILURE: Differences detected between the runs.")
+        sys.exit(1)

episodes/files/ZPeakAnalysis/test/check_cutflows.py

@@ -0,0 +1,45 @@
+import ROOT
+import sys
+
+# Define the input and output filenames
+input_file = 'myZPeak.root'
+output_txt = 'number_of_events.txt'
+
+# Open the ROOT file
+f = ROOT.TFile.Open(input_file)
+if not f or f.IsZombie():
+    print(f"Error: Could not open {input_file}")
+    sys.exit(1)
+
+# In TFileService, histograms are usually inside a directory
+# named after the module label in your python config.
+# Based on your config, the label is 'analyzeBasicPat'
+dir_name = "analyzeBasicPat"
+hist_dir = f.Get(dir_name)
+
+if not hist_dir:
+    print(f"Error: Directory {dir_name} not found in {input_file}")
+    f.ls() # List contents to help debugging
+    sys.exit(1)
+
+# Retrieve the histograms
+h_muonMult = hist_dir.Get("muonMult")
+h_eleMult  = hist_dir.Get("eleMult")
+h_mumuMass = hist_dir.Get("mumuMass")
+
+# Calculate integrals
+# Integral() returns the sum of bin contents (excluding under/overflow by default)
+muon_integral = h_muonMult.Integral()
+ele_integral  = h_eleMult.Integral()
+mumuMass_integral = h_mumuMass.Integral()
+
+# Write to a text file
+with open(output_txt, 'w') as f_out:
+    f_out.write(f"muonMult: {muon_integral}\n")
+    f_out.write(f"eleMult:  {ele_integral}\n")
+    f_out.write(f"mumuMass: {mumuMass_integral}\n")
+
+print(f"Successfully wrote integrals to {output_txt}")
+
+# Close ROOT file
+f.Close()

episodes/files/ZPeakAnalysis/test/check_number_events.py

@@ -0,0 +1,3 @@
+muonMult: 54856.0
+eleMult:  54856.0
+mumuMass: 16324.0