HepSim

User Tools

Site Tools

Trace:
hepsim:jas4pp

Differences

This shows you the differences between two versions of the page.


—hepsim:jas4pp [2024/07/01 21:25] (current) – created - external edit 127.0.0.1
Line 1: Line 1:
 +
 +{{indexmenu_n>17}}
 +
 +[[:|<< back to HepSim manual]]
 +
 +======  Jas4pp description ======
 +
 +[[https://atlaswww.hep.anl.gov/asc/jas4pp/ | Jas4PP program]] is 
 +a data-analysis environment for detector and physics studies of future circular colliders.
 +Jas4PP is a merge of several open-source Java projects, such as [[http://www.lcsim.org|lcsim.org]] [(Simulator for the linear collider (SLIC): A tool for ILC detector simulations. N. Graf and  J. McCormick, http://inspirehep.net/record/736286?ln=en)], [[http://lcio.desy.de/ |LCIO event model]], [[http://java.freehep.org/|FreeHep]], [[https://datamelt.org|DataMelt]] (community edition) and  [[http://atlaswww.hep.anl.gov/hepsim|hs-tools]] of HepSim. It also supports Java-implemented anti-KT jets. The package is designed to work using the Python language (it includes Jython 2.7, which is compatible with the 2.7 version of CPython), or using the standard Java coding. All HEP Jas plugins are included (and some of them were modified to work with DataMelt).
 +
 +
 +The installation does not have external dependencies besides Java. Make sure that Oracle Java8 and above is installed (not OpenJDK).
 +You can download the Jas4pp program using the [[https://atlaswww.hep.anl.gov/asc/jas4pp/download/|download page]].
 +Then run these commands to install the package using Linux/Mac with the "bash" shell:
 +
 +<code bash>
 +wget https://atlaswww.hep.anl.gov/asc/jas4pp/download/current.php -O jas4pp.tgz
 +tar -zvxf jas4pp.tgz
 +cd jas4pp
 +source ./setup.sh # takes 5 sec for first-time optimization
 +</code>
 +The last command optimizes Java packages for the Python language.
 +Now you are ready to run over  any file with truth-level and datector-simulation files, such as LCIO and ProMC. Here are the included commands:
 +
 +
 +
 +<code bash>
 +jaspp          # start Jas4pp with preconfigured HEP plugins (Linux/Mac with bash)
 +jaspp.bat      # same for Windows
 +fpad           # run Jython scripts in a batch mode (Linux/Mac with bash) 
 +fpad_edit      # start a minimalistic Python editor "FPAD") and Jython shell
 +fpad_edit.bat  # same for Windows
 +gconverter     # geometry converters
 +gconverter_gui # same in GUI mode
 +hs-help        # shows commands to access data from the HepSim repository
 +</code>
 +
 +Use these programs for:
 +
 +  * Downloading and searching HepSim data
 +  * Processing ProMC files from HepSim
 +  * Processing ROOT files created by the Delphes program for fast simulation
 +  * Running over SLCIO files with Geant4 simulated / reconstructed events.
 +  * Data analysis (jets, physics vectors, histogram packages)
 +  * Visualization of reconstructed events using Wired4 display
 +
 +You can find more details in [[https://atlaswww.hep.anl.gov/hepsim/doc/doku.php|HepSim manual]].
 +
 +
 +<note tip>Note that you can also use the [[hepsim:dev_singularity|HepSim Singularity/Docker container]] with included
 +Jas4pp</note>
 +
 +====== Examples ======
 +
 +All examples of Jas4pp are collected in the directory "examples". Run them as:
 +
 +<code bash>
 +fpad examples/dmelt/histo1.py                 # DMelt histogram example
 +fpad examples/jaida/Fit.py                    # Jas/Aida fit example
 +fpad examples/hepsim/pythia6_zpole_tautau.py  # run over HepSim Monte Carlo data
 +</code>
 +The last example from the [[https://atlaswww.hep.anl.gov/hepsim/|HepSim web page]] prints the pT distribution of e, mu, taus.
 +You can also run these examples as "fpad_edit file.py" or using the Jas-like environment (i.e. jaspp program).
 +
 +
 +Here is an example of how to compare data points with a histogram using DMelt classes.
 +Run this script as "fpad file.py", or open it in the Jas4pp editor and run this script.
 +
 +<hidden Click to show the Python code>
 +<code python>
 +from java.awt import *
 +from java.util import Random
 +from jhplot  import *
 +
 +c1 = HPlot()
 +# c1.doc()  # view documentation
 +c1.setGTitle("F_{2},  x_{&gamma;}  #bar{p}p F_{2}^{c#bar{c}}") 
 +c1.visible(1)
 +c1.setAutoRange()
 +c1.setMarginLeft(85) # make space for Y label
 +c1.setNameX("X")
 +c1.setNameY("Y")
 +
 +h1 = H1D("MC",25, -2, 2.0)
 +h1.setPenWidthErr(2) # line width
 +h2 = H1D("data",25, -2, 2.0)
 +
 +r=Random()
 +for i in range(10000):
 +   h1.fill(r.nextGaussian())      
 +   h2.fill(r.nextGaussian())          
 +
 +p1=P1D(h2) # convert to X-Y array 
 +c1.draw(h1)
 +c1.draw(p1)
 +# c1.drawStatBox(h1)
 +
 +# set HLabel in the normilised coordinate system
 +lab=HLabel("HLabel in NDC", 0.18, 0.7, "NDC")
 +lab.setColor(Color.blue)
 +c1.add(lab)
 +
 +c1.update()
 +c1.export("image.eps") 
 +</code>
 +</hidden>
 +
 +Run this example in Jas4pp and look at this image:
 +
 +<hidden Click to show the image>
 +{{:asc:histo1.png|Histogram}}
 +</hidden>
 +
 +
 +====== Reading LCIO files ======
 +
 +Jas4pp can be used to process LCIO files. This can be done using Java, or Python (Jython). The examples are given in the directory "example".
 +<hidden Click to show the Python code>
 +<code python>
 +# Example of processing SLCIO files using Jas4pp
 +# Setup Jas4pp using "source setup.sh".
 +# Then create the directory "data"  and fill it with SLCIO files using has-get command,
 +# and run this script as "fpad example.py data"
 +
 +from org.lcsim.lcio import LCIOReader
 +from hep.io.sio import SIOReader
 +from hep.lcio.implementation.sio import SIOLCReader
 +from hep.lcio.implementation.io import LCFactory
 +from hep.lcio.event import * 
 +from hep.lcio.io import *
 +from jhplot import *
 +from hephysics.particle import LParticle
 +import math
 +import os,sys
 +from java.lang import System;
 +
 +# get directory name from the argument
 +filename = sys.argv[1]
 +
 +# make list of files..
 +import glob
 +files = glob.glob(filename+"/*.slcio")
 +factory = LCFactory.getInstance()
 +
 +nEvent=0
 +for f in files:
 +    print "Open file=",f
 +    reader = factory.createLCReader()
 +    reader.open(f) 
 +    while(1):
 +        evt=reader.readNextEvent()
 +        if (evt == None): break
 +        nEvent=nEvent+1
 +        # print " file event: ",evt.getEventNumber(), " run=",evt.getRunNumber()
 +        if (nEvent%100==0): print "# Event: ",nEvent
 +        col    = evt.getCollection("MCParticle")
 +        colPF  = evt.getCollection("PandoraPFOCollection");
 +        colCl  = evt.getCollection("ReconClusters");
 +        colTr  = evt.getCollection("Tracks");
 +        colECB = evt.getCollection("EM_BARREL");
 +        colHCB = evt.getCollection("HAD_BARREL");
 +
 +        nMc=col.getNumberOfElements();
 +        nPF=colPF.getNumberOfElements();
 +        nCl=colCl.getNumberOfElements();
 +        nTr=colTr.getNumberOfElements();
 +        nECB=colECB.getNumberOfElements();
 +        nHCB=colHCB.getNumberOfElements();
 +        # now you can access all data here
 +     
 +        # manage memory if too much data 
 +        del col
 +        del colPF
 +        del colCl
 +        del colTr
 +        del colECB
 +        del colHCB
 +        del evt
 +
 +    reader.close() # close the file
 +    del reader
 +    System.gc()    #  force memory cleanup, if needed 
 +</code>
 +</hidden>
 +To process SLCIO files from a directory "data", call this script "example.py as:
 +
 +<code>
 +fpad example.py data
 +</code>
 +The script open each file, and access every container in the file.
 +Note that we explicitly mange memory in case of very large files, forcing the garbage collector for each file. In many cases, this is not needed since JVM takes care of memory leakage.
 +
 +You can find more examples in [[:hepsim:usage_full|this section]] and in the directory "examples" of Jas4pp.
 +
 +Also, look at concrete example of how to analyze single particles in [[:fcs:eic:intro|this section]].
 +
 +
 +======  Reading ROOT files ======
 +
 +Jas4pp natively reads commonly used objects and data structures from [[https://root.cern/ | ROOT files]]  (versions 3, 4, 5 and 6). 
 +ROOT files can be loaded using the Jas4pp menu [File]-[Open data source]-[Root file] (*.root).
 +
 +In addition, one can work with ROOT files using Python/Jython or Groovy scripts. 
 +One can find some examples in the directory "examples/root".  Here is a Jython/Python example showing how to read a ROOT tree:
 + 
 +<hidden Show example of a Python code here>
 +<code python>
 +from  hep.io.root.interfaces import TTree
 +from  hep.io.root import RootFileReader
 +
 +reader = RootFileReader("ntuple_tree.root")
 +
 +tree = reader.get("tree");
 +maxevents=tree.getEntries()
 +
 +leaves = tree.getLeaves()
 +nrleaves=leaves.size()
 +
 +print "Nr of events=",maxevents
 +print "Nr of leaves=",nrleaves
 +
 +print "Leaves:"
 +for l in xrange( nrleaves ):
 +   print "Leaf=",(leaves.get(l)).getName()
 +
 +print "Run over events"
 +f0=leaves.get(0);
 +f1=leaves.get(1);
 +f2=leaves.get(2);
 +for i in xrange(tree.getEntries()):
 +      print f0.getValue(i), f1.getValue(i), f2.getValue(i)
 +
 +</code>
 +</hidden>
 +
 +The example directory also shows how to read histograms.
 +Similar examples can be made using Java or Groovy scripting.
 +
 +The supported ROOT interfaces are:
 +
 +<hidden show more details on ROOT interfaces here>
 +TArrayC
 +TArrayD
 +TArrayF
 +TArrayI
 +TArray
 +TArrayL
 +TAttAxis
 +TAttFill
 +TAttLine
 +TAttMarker
 +TAxis
 +TBasket
 +TBranchClones
 +TBranchElement
 +TBranch
 +TBranchObject
 +TClonesArray
 +TCollection
 +TDatime
 +TDirectory
 +TFile
 +TGraph
 +TH1D
 +TH1F
 +TH1
 +TH2D
 +TH2F
 +TH2
 +TKey
 +TLeafB
 +TLeafC
 +TLeafD
 +TLeafElement
 +TLeafF
 +TLeafI
 +TLeaf
 +TLeafL
 +TLeafObject
 +TLeafO
 +TLeafS
 +TList
 +TMap
 +TNamed
 +TObjArray
 +TObject
 +TProfile
 +TSeqCollection
 +TStreamerBase
 +TStreamerBasicPointer
 +TStreamerBasicType
 +TStreamerElement
 +TStreamerInfo
 +TStreamerLoop
 +TStreamerObjectAny
 +TStreamerObject
 +TStreamerObjectPointer
 +TStreamerString
 +TString
 +TTree
 +</hidden>
 +
 +One can browser histogram (or ROOT objects) using this:
 +
 +<code python>
 +import rootio
 +rootio.HBrowser("histograms_root5.root") # browser and plot ROOT histograms 
 +rootio.Browser("histograms_root5.root")  # browser for ROOT objects
 +</code>
 +
 +You will see the browsers:
 +
 +{{:hepsim:browser_histograms.png?300|Histogram browser}}
 +
 +{{:hepsim:root_browser.png?300|Object browser}}
 +
 +The script that call these browsers  can be put into Jython or Groovy files and executed as binary programs.
 +
 +
 +To read ROOT files from Delphes simulations, use 
 +[[https://atlaswww.hep.anl.gov/asc/jas4pp/api/rootio/Delphes.html|Delphes class]] and its "get" methods,
 +getFloat, getDouble, getInt, and getBool. But first, explore the Delphes ROOT file using the browser shown above.
 +
 +Here is an example that uses high-level classes to read transverse momentum (PT) and pseudorapidity (ETA) of Monte Carlo particles:
 +
 + 
 +<hidden Click here to show  a Python code to read Delphes files>
 +<code python>
 +from  hep.io.root import RootFileReader
 +from rootio import *
 +
 +reader = RootFileReader("mg5_ttbar_Njet_001.root" )
 +tree = reader.get("Delphes");
 +maxevents=tree.getEntries()
 +branches=tree.getBranches()
 +print "Nr of events=",tree.getEntries()
 +print "Nr of branches=",branches.size()
 +print "Branches:"
 +for l in xrange( branches.size()  ):
 +   print "Branch=",l," name=",(branches.get(l)).getName()
 +
 +particles=tree.getBranch("Particle") # get  generator particles
 +
 +ptEvents=Delphes.getFloat(particles,"PT")   # get PT array
 +etaEvents=Delphes.getFloat(particles,"Eta") # get ETA array
 +
 +from jhplot import *
 +h1 = H1D("PT of particles",100, 0, 100)
 +h2 = H1D("Eta of particles",100, -4, 4)
 +for i in xrange(tree.getEntries()):
 +       pt,eta=ptEvents[i],etaEvents[i]
 +       for j in xrange(len(pt)):
 +           h1.fill(pt[j])
 +           h2.fill(eta[j])
 +c=HPlot("pT",600,300,2,1)
 +c.visible()
 +c.setAutoRange()
 +c.draw(h1)
 +
 +c.cd(2,1)
 +c.setAutoRange()
 +c.draw(h2)
 +</code>
 +</hidden>
 +
 +{{:hepsim:pt_eta_delphes.png?300|}}
 +
 +<note warning>Reading Delphes trees is an experimental feature. Under study </note>
 +
 +====== Using GUI mode ======
 +
 +
 +You can also run Jas4pp in a GUI mode. You can process scripts that read PROMC and LCIO files from these HepSim pages:
 +
 +  - [[https://atlaswww.hep.anl.gov/hepsim/macrolist.php|EVGEN validation scripts]]
 +  - [[https://atlaswww.hep.anl.gov/hepsim/macrolist_lcio.php|LCIO validation scripts]]
 +
 +
 +Download any of these scripts, and open it using the "jaspp" program. Then you can run the script using the right-mouse menu ("run script"). You will see the output below the main editor. Each run creates a new tab with the output. Look at this example:
 +
 +{{:hepsim:jas4pp_gui.png?400|}}
 +
 +
 +
 +====== Programming with HepSim ======
 +
 +
 +Jas4pp can be used to write Jython scripts to validate HepSim ProMC files. Please look at
 +[[https://atlaswww.hep.anl.gov/asc/promc/|Programming with ProMC files]] section.
 +
 +
 +====== Java API ======
 +
 +
 +===== Plots and histograms =====
 +
 +
 +
 +
 +Jas4pp uses histogram packages supported by both DMelt (community edition) or JAIDA (FreeHep).
 +DMelt provides programming API similar to PyROOT and with classes named conveniently to reduce code verbosity. 
 +
 +Here are a few most common classes:
 +
 +  * [[https://datamelt.org/api/doc.php/jhplot/HPlot|HPlot]] - canvas to show X-Y data and histograms in 2D
 +  * [[https://datamelt.org/api/doc.php/jhplot/HPlot|HPlot3D]] - canvas to show X-Y-Z data and histograms in 3D
 +  * [[https://datamelt.org/api/doc.php/jhplot/H1D|H1D]] - 1D histogram
 +  * [[https://datamelt.org/api/doc.php/jhplot/H1D|H2D]] - 2D histogram
 +  * [[https://datamelt.org/api/doc.php/jhplot/P1D|P1D]] - X-Y container with support of 2-level errors
 +
 +The main canvas to show histograms [[http://jwork.org/dmelt/api/doc.php/jhplot/H1D|H1D]] and data points  [[http://jwork.org/dmelt/api/doc.php/jhplot/P1D|P1D]]  is [[http://jwork.org/dmelt/api/doc.php/jhplot/HPlot|HPlot]]. To process scripts in a background without a pop-up [[http://jwork.org/dmelt/api/doc.php/jhplot/HPlot|HPlot]], use method "visible(False)", and set sys.exit(0) at the end of the scripts.  You can also use the JAIDA to make histograms (Histogram1D or Histogram2D). 
 +In addition, data are saved in the form of XML (with the extension ".jdat") files. Look the manual [[https://handwiki.org/wiki/DMelt:Start]].
 +
 +===== Lorentz particles and Jets =====
 +
 +  * [[https://datamelt.org/api/doc.php/hephysics/hepsim/PromcUtil|PromcUtil]] convenient method to fill arrays with particles from ProMC files
 +  * [[https://datamelt.org/api/doc.php/hephysics/particle/LParticle|LParticle]] a HEP particle with the Lorentz transformations
 +  * [[https://datamelt.org/api/doc.php/hephysics/jet/FastParticle|FastParticle]] a HEP particles with precomputed Et2,Eta,Phi for jet algorithms. 
 +  * [[http://java.freehep.org/freehep-physics/apidocs/hep/physics/vec/package-summary.html|Physics vectors]] typical HEP physics vectors the Lorentz transformations
 +  * [[https://datamelt.org/api/doc.php/hephysics/jet/JetN2|JetN2]] recommended kt-type jet clustering ng algorithms (kT, anti-kT, CA) implemented in Java using N^2 approach, similar to the FastJet algorithm. Recommended for hadron collisions
 +  * [[https://datamelt.org/api/doc.php/hephysics/jet/SCJet|SCJet]] traditional kt-type jet clustering algorithms (kT, anti-kT) for pp implemented in Java using N^3 approach (slow) 
 +  * [[http://java.freehep.org/freehep-physics/apidocs/hep/physics/jet/package-summary.html|Jets and event shapes]] traditional jet algorithms and event shapes for e+e- from FreeHep (Geneva, Jade, Durham jets) 
 +  
 +  
 +Java implementation of the longitudinally invariant kT and anti-kT clustering algorithms uses the E-scheme to combine particles (p1+p2) and Eta-Phi space (not Rapidity-Phi). Also, Cambridge/Aachen jets are supported.   [[https://github.com/chekanov/hepjet/|HepJet on github]] shows  benchmarks of the Java implementation of the anti-KT with the original FastJet package.
 +
 +
 +You can build the standard kt-jets using [[http://datamelt.org/api/doc.php/hephysics/hepsim/PromcUtil | PromcUtil]], followed by the 
 +[[https://datamelt.org/api/doc.php/hephysics/jet/KTjet | KTjet]] class. 
 +
 +
 +====== Visualizing a detector Jas+Wired ======
 +
 +You can run Jas+Wired to visualize the simulated events.  The Wired program is included in Jas4pp, so you simply run it as:
 +<code bash>
 +./jaspp
 +</code>
 +This will start a Jas3-like environment  with all needed plugins. 
 +Then copy the detector geometry file from the [[https://atlaswww.hep.anl.gov/hepsim/soft/detectors/| detector repository]].
 +<code bash>
 +wget https://atlaswww.hep.anl.gov/hepsim/soft/detectors/sidloi3.tgz -O - | tar -xz;
 +</code>
 +This will create a directory "sidloi3". This detector corresponds to "rfull001" tag used for the reconstruction of pythia6_zpole_ee (Z->e+e-). 
 +
 +Now we can visualize the detector as **[File]-[Open data source]-[HepRep]** XML and select the file "sidloi3.heprep" from sidloi3.tgz:
 +This is how to do this using the command line:
 +
 +<code bash>
 +./jaspp  sidloi3.heprep
 +</code>
 +You will see the detector layout:
 +
 +{{:fcs:detector.png?400|Whired4 event display}}
 +
 +Now, we will read the event: Open any *.slcio file you copied from HepSim as 
 +**[File]-[Open data source]-[LCIO]** file.  Then click a small button [Go] (top menu bar). It will process
 + events.  Then select again **[File]-[New]-[Wired 4 view]**.  You will get an image in the Wired4 display.
 +Now press [Go] again to look at next event.
 +If you want to see how data records are organized inside the slcio file,
 +do this **[File]-[New]-[LCSim Event browser]**
 +
 +
 +Here is an example of how to visualize LCIO files from the [[http://atlaswww.hep.anl.gov/hepsim/|HepSim repository]]:
 +
 +<code bash>
 +wget https://mc.hep.anl.gov/asc/hepsim/events/misc/pgun/pgun_eta35_muon//rfull009/pgun_muon1024gev_001_pandora.slcio
 +./jaspp pgun_muon1024gev_001_pandora.slcio
 +</code>
 +
 +Click "Go" in the menu. Now you can open the event browser or Wired event display. Look at event record as
 +"File->New->Event Browser". Similarly, visualize the event as "  File->New->Wired4 View". It shows an black window on the left.
 +Then go to the next event, click "Go next" in the menu. This image illustrates a single electron event:
 +
 +{{:hepsim:electron_event.png?400|Whired4 event display}}
 +
 +Similarly, you can view any events form the HepSim directory. The LCIO event file automatically installs
 +the required detector geometry, i.e.  when you open a SLCIO file from the HepSim, you do not need to load the geometry file. The geometry file will be downloaded automatically from HepSim and will be put to ".lcsim/cache/" inside your home directory. 
 +
 +
 +
 +====== Visualizing geometry using ROOT ======
 +(contribution from N.Nikiforou):
 +
 +You can also visualize the detector using ROOT. Here are a few steps:
 +Locate the file detector.gdml inside the file detector.zip (where "detector" shows the name of the detector). 
 +
 +
 +<hidden show more details here>
 +This file is created using this command during the detector design stage
 +<code>
 +slic -g detector.lcdd -G detector.gdml
 +</code>
 +</hidden>
 +
 +Once you have the GDML file, you can use ROOT to visualize it. You just
 +need to make sure the ROOT installation has openGL/GDML support (CERN
 +AFS installations have it for sure). At the ROOT prompt do:
 +
 +<code cpp>
 +TGeoManager::Import("detector.gdml");
 +gGeoManager->GetTopVolume()->Draw("ogl");
 +</code>
 +This should popup an OpenGL display with the detector which you can
 +clip, pan, rotate etc. You will the image as shown here:
 +
 +{{:asc:image.png?400|}}
 +
 +
 +====== People ======
 +
 +  * S.Chekanov (ANL, main developer)
 +  * E.May (ANL, debugging, Wired4)
 +  * Gagik Gavalian (JLab)
 +
 +
 +====== Additional help ======
 +
 +
 +  * [[http://jas.freehep.org/jas3/]] - JAS3
 +  * [[http://java.freehep.org/]] - FreeHep
 +  * [[http://datamelt.org]] - DataMelt
 +  * [[https://confluence.slac.stanford.edu/display/ilc/ILC+Detector+Simulation+FAQ]] - SLIC
 +  * [[https://confluence.slac.stanford.edu/display/ilc/LCSim+Tutorials]] - SLIC
 +  * [[https://atlaswww.hep.anl.gov/asc/promc/]] ProMC file format
 +  * [[http://lcio.desy.de/]] LCIO file format
 +
 +
 +
 + --- //[[[email protected]|Sergei Chekanov]] 2016/03/23 21:53//
 + 
  
hepsim/jas4pp.txt · Last modified: 2024/07/01 21:25 by 127.0.0.1