Pages in New

Go HEP release 0.28.0


Release v0.28.0 is out of the oven. This release contains a major new groot related feature: the ability to write non-split user types, by way of TBranchElement and TLeafElement. write-full-split type write-non-split type csvutil add support for writing slices (thanks Chinmaya Krishnan Mahesh (chin123)!) groot add support for writing large files (i.e.: with size > 2Gb) changed the way groot streamers are created and handled (read/write) from ROOT ones removed rtree.

Go HEP release 0.27.0


Release v0.27.0 is out of the oven. This release contains a major groot performance improvement. As can be seen from groot-bench, groot can now read ROOT files (compressed or not) faster than (naive?) C++/ROOT 6.20/04 code (w/ TTree::Branch or TTreeReader): name time/op ReadCMS/GoHEP/Zlib-8 19.2s ± 1% ReadCMS/ROOT-TreeBranch/Zlib-8 37.5s ± 1% ReadCMS/ROOT-TreeReader/Zlib-8 26.1s ± 3% ReadCMS/ROOT-TreeReaderMT/Zlib-8 25.6s ± 5% (ROOT::EnableImplicitMT()) This was achieved by: re-engineering the reading code into dedicated rleafXyz, rbasket, … types introducing a rbasket (concurrent) pre-fetcher There are still a few low-hanging fruits to reap performances wise (reducing memory usage, reusing rbasket buffers, reusing rbasket buffers across decompression goroutines, etc…)

Go HEP release 0.23.0


Release v0.23.0 is fresh from the oven. This release contains a couple of groot related features and bugfixes. groot groot gained 2 new commands: cmd/root2fits converts a ROOT TTree into a FITS table: $> root2fits -h root2fits converts the content of a ROOT tree to a FITS (binary) table. Usage: root2fits [OPTIONS] -f input.root Example: $> root2fits -f ./input.root -t tree Options: -f string path to input ROOT file name -o string path to output FITS file name (default "output.

Go HEP release 0.22.0


Release v0.22.0 is fresh from the oven. This release contains a couple of groot related features and bugfixes. groot Building on the work on tree-writing from v0.21.00, groot gained 3 new commands: cmd/arrow2root converts an ARROW data file into a corresponding ROOT tree, $> arrow2root testdata/primitives.file.data $> root-ls -t output.root === [./output.root] === version: 61804 TTree tree tree (entries=10) bools "bools/O" TBranch int8s "int8s/B" TBranch int16s "int16s/S" TBranch int32s "int32s/I" TBranch int64s "int64s/L" TBranch uint8s "uint8s/b" TBranch uint16s "uint16s/s" TBranch uint32s "uint32s/i" TBranch uint64s "uint64s/l" TBranch float32s "float32s/F" TBranch float64s "float64s/D" TBranch cmd/npy2root converts a NumPy data file into a correspondig ROOT tree, $> npy2root -h npy2root converts the content of a NumPy data file to a ROOT file and tree.

Go HEP release 0.21.0


Release v0.21.0 is fresh from the oven. This release contains a major new groot feature: the ability to write (simple, flat) trees, including variable-length arrays (a.k.a slices): groot/rtree–CreateFlatNtuple groot/rtree–CreateFlatFromStruct groot/rtree–CreateFlatNtupleWithLZMA groot groot supports more ROOT-4 files (as created by Geant4: TH{1,2}x and TTree) fixed compilation on 32b systems add groot/rtree.WriterVarsFromStruct to generate a slice of rtree.WriterVars from a user-provided struct that can be then used to fill a tree add With{LZ4,LZMA,Zlib} and WithoutCompression functions to configure whether a tree should use compression (and what kind of compression, if any) add WithBasketSize to configure the basket size of trees/branches add auto-flushing of branches’ baskets godoc:example

Go HEP release 0.20.0


Release v0.20.0 is fresh from the oven. This release contains a major new groot feature: the ability to write (simple, flat) trees: groot/rtree#NewWriter and a couple of new features for hplot. groot groot support has been bumped to ROOT-6.18/04 groot can now create nested directories that are compatible with ROOT. Previously, groot would create nested directories which could only be read back by groot (and uproot). w, err := groot.

Go HEP release 0.19.0


Release v0.19.0 is fresh from the oven. This release contains 3 new groot-related packages: groot/rsql/rsqldrv: a package to present a ROOT File+Tree as a SQL database, by way of implementing the database/sql/driver interface for groot groot/rsql: a convenience package to scan (a la TTree::Scan and TTree::Draw) rtree.Tree and create hbook.H1D or hbook.H2D groot/rarrow: a package to present rtree.Tree as Apache Arrow’s Tables and Records. This will be very useful for interoperability with DataScience and/or Machine Learning toolkits.

Go HEP release 0.18.0


Release v0.18.0 is fresh-ish from the oven. This release contains the beginning of an XRootD server in Go (thanks Mikhail!) as well as yet more groot improvements. fit fit: update for new gonum.org/v1/gonum/optimize API fit: use new gonum/{diff/fd,optimize} API groot groot/riofs.Open and thus groot.Open have been modified to only open local files by default. A “plugin” mechanism has been devised to be able to optionally install plugins to deal with, e.

Go HEP release 0.17.1


Release v0.17.1 is fresh-ish from the oven. This new release continues the refactoring and consolidation work of the groot package (meant to replace rootio.) brio brio/cmd/brio-gen gained some documentation groot groot/rdict has seen a bunch of work to create user-type StreamerInfos, groot/cmd/root-gen-streamer: new command to automatically generate a StreamerInfo and its StreamerElements given a ROOT or user type, groot/rdict now properly handles streamers with arrays of builtins, and properly visits std::vector<T> fields (where T is a builtin) groot/cmd/root-dump: now properly handle root.

Go HEP release 0.16.0


Release v0.16.0 is fresh from the oven. This new release introduces a new package, groot, that replaces rootio. groot & rootio groot is a new package that is meant to replace rootio. For backward compatibility, rootio will remain in the repository for a couple of releases (presumably until v1.0.0.) groot is the result of refactoring rootio in a couple of more focused packages with clear API boundaries: groot/rbase: definitions of basic ROOT classes (Object, Named, ObjString, …) groot/rbytes: definitions of types useful for serializing and deserializing ROOT data buffers, interfaces to interact with ROOT’s metadata classes such as StreamerInfo and StreamerElements.

Go HEP release 0.15.0


Release v0.15.0 is fresh from the oven. This new release dropped explicit support for Go-1.8.x but, in turn, gained support for Go-1.11.x and “Go Modules”. In a nutshell, Go modules allow to explicitly declare what are the dependencies a given module needs for the go build tool to successfully build it. And, more importantly, Go modules allow to explicitly declare what are the needed versions of these dependencies, essentially making a build completely reproducible.

Go HEP release 0.14.0


Release v0.14.0 is fresh from the oven. This release is the result of some massive work in the xrootd package thanks to Mikhail Ivchenko (a.k.a @EgorMatirov), our Google Summer of Code 2018 student. While GSoC-2018 is now over, it’s time to reflect on what Mikhail wrote: an almost complete xrootd client, compatible with the C++ implementation; xrd-fuse, a command to mount the contents of a remote XRootD server, locally; the beginnings of an xrootd server.

Go HEP release 0.13.0


Release v0.13.0 is fresh from the oven. This release ships with major improvements in the xrootd implementation and a few fixes in rootio. rootio leveraging the work that happened in xrootd, rootio is now able to read files over [x]root: import ( "go-hep.org/x/hep/rootio" ) func foo() { f, err := rootio.Open("root://ccxrootdgotest.in2p3.fr:9001/tmp/rootio/testdata/small-flat-tree.root") if err != nil { … } defer f.Close() } all the root-xyz commands can now also leverage xrootd: $> root-ls -t root://ccxrootdgotest.

Go HEP release 0.12.0


Release v0.12.0 is fresh from the oven. This release is the first one to introduce preliminary support for vgo, the official Go way to handle versioning. vgo is still in flux: the first Go version with experimental opt-in support should be Go 1.11 (to be released in August 2018.) Obviously, on the Go-HEP side, adjustments will probably still be required as the user story solidifies and experience is accumulated.

Go HEP release 0.11


Release v0.11 is fresh from the oven. This release drops official support for Go-1.7 and earlier, adds support for Go-1.10. This allowed to migrate the fwk package away from golang.org/x/net/context. fwk now directly uses the context.Context type from the standard library. rootio This release brings quite a few improvements in the rootio area: add support for empty ROOT files, add support for reading remote ROOT files over HTTP. This is implemented in a quite naive way, using net/http.

Go HEP release 0.10


Release v0.10 is fresh from the oven. This release brings quite a few improvements in the rootio area: support for ROOT files compressed with LZMA support for ROOT files compressed with LZ4 support scanning ROOT trees with branches holding multiple leaves support for ROOT trees holding bool, [X]bool and std::vector<bool> support for ROOT files holding TBranch version 10 support for ROOT files holding TBranchElement version 8 support for ROOT files holding TH1 version 5 support for ROOT trees and branches produced with ROOT-6.

Go HEP release 0.9


Release v0.9 is fresh from the oven. This is a quick and simple release fix with the following main features: fix a broken link to the PDF LaTeX example (back from the multi- to mono-repo migration) fix a compilation failure in rootio/cmd/root-srv originating from an API modification in a 3rd-party dependency (github.com/satori/go.uuid) One interesting new feature is the introduction of a simple ROOT::TTree to CSV file conversion command: root2csv.

Go HEP release 0.8


Release v0.8 is fresh from the oven. No API changes in go-hep itself, just a few modifications to cater with changes in gonum/v1/gonum and gonum/v1/plot: gonum/v1/gonum/stat/distuv distributions replaced the name of their rand.Rand source field from Source to Src (to align with the standard library) gonum/v1/gonum/stat/… packages now use golang.org/x/exp/rand.Rand instead of math/rand.Rand The biggest news (and where the work mostly happened between v0.7 and v0.8) is that there’s now a Jupyter instance with a Go kernel installed with Go-HEP and Gonum libraries pre-installed.

Go HEP release 0.7


Release v0.7 is fresh from the oven with a few breaking API changes. cmd/yoda The cmd/rio2yoda, cmd/root2yoda and cmd/yoda2rio commands now support gzipped YODA files. The cmd/yoda2rio is also more lenient when dealing with YODA objects that are not yet supported on the hbook side (Counter, S1D, …) (thanks Lukas Heinrich for the report.) fastjet Bastian added the ability to plot the Voronoi diagram from a set of 2D-points.

Go HEP release 0.6


Release v0.6 is a small iteration (code-wise) but contains: a software paper submitted to the Journal of OpenSource Software (JOSS): a new WIP command, rootio/cmd/root-dump, to dump the content of ROOT files, including the entries of TTrees, documentation fixes and updates in the rootio package, still more work in the Delaunay and Voronoi area (thanks Bastian!) One API change that is worth noting, is the retrieval of rootio.

Go HEP release 0.5


Release v0.5 has seen some interesting work.

General Go-HEP has migrated all its Gonum imports to use "gonum.org/v1/gonum/{mat,stat,…}", instead of the old "github.com/gonum/{mat64,stat,…}" Go-HEP has also migrated all its use of gonum/plot from "github.com/gonum/plot/…" to the new "gonum.org/v1/plot/…" Go-1.6’s support has been dropped from the Travis-CI matrix Go-1.9’s support has been added to the Travis-CI matrix rootio The rootio package has seen most of the work: performance improvements for reading ROOT files, a new root2npy command and the beginning of the work to provide write support.


Go HEP release 0.4


Release v0.4 is a small iteration (because of holidays.) But still, it does bring interesting things to the table: root2npy, a new command to convert the content of simple TTrees into a NumPy data file, migration from the github.com/gonum/xyz packages to their new location – gonum.org/v1/gonum/xyz, fastjet preliminary work for implementing better/faster jet clustering, thanks Bastian Wieck hplot make the hplot.H1D type implement gonum/plot.Thumbnailer (for better integration with legends and labels) lcio fix a bug in the marshaling of lcio.

Go HEP release 0.3


Release v0.3 brings read support for ROOT TTrees containing user-defined classes. Not everything is supported, though. Changelog: https://github.com/go-hep/hep/releases/v0.3 Sources (zip): https://github.com/go-hep/hep/archive/v0.3.zip Sources (tar): https://github.com/go-hep/hep/archive/v0.3.tar.gz DOI: https://doi.org/10.5281/zenodo.574888 rootio What is supported and tested so far (in no-split and full-split mode): https://github.com/go-hep/hep/blob/v0.3/rootio/gendata/gen-evnt-tree.go#L51 // edm.cxx struct P3 { int32_t Px; double Py; int32_t Pz; }; struct Event { TString Beg; int16_t I16; int32_t I32; int64_t I64; uint16_t U16; uint32_t U32; uint64_t U64; float F32; double F64; TString Str; P3 P3; int16_t ArrayI16[ARRAYSZ]; int32_t ArrayI32[ARRAYSZ]; int64_t ArrayI64[ARRAYSZ]; uint16_t ArrayU16[ARRAYSZ]; uint32_t ArrayU32[ARRAYSZ]; uint64_t ArrayU64[ARRAYSZ]; float ArrayF32[ARRAYSZ]; double ArrayF64[ARRAYSZ]; int32_t N; int16_t *SliceI16; //[N] int32_t *SliceI32; //[N] int64_t *SliceI64; //[N] uint16_t *SliceU16; //[N] uint32_t *SliceU32; //[N] uint64_t *SliceU64; //[N] float *SliceF32; //[N] double *SliceF64; //[N] std::string StdStr; std::vector<int16_t> StlVecI16; std::vector<int32_t> StlVecI32; std::vector<int64_t> StlVecI64; std::vector<uint16_t> StlVecU16; std::vector<uint32_t> StlVecU32; std::vector<uint64_t> StlVecU64; std::vector<float> StlVecF32; std::vector<double> StlVecF64; std::vector<std::string> StlVecStr; TString End; }; which can be read with a Go struct with the same layout, translating std::vector<T> into slices of T, std::string and TString into Go string, etc… see:

Go HEP release 0.2


Two weeks after release v0.1, here is v0.2: Changelog: https://github.com/go-hep/hep/releases/v0.2 Sources (zip): https://github.com/go-hep/hep/archive/v0.2.zip Sources (tar): https://github.com/go-hep/hep/archive/v0.2.tar.gz DOI: https://doi.org/10.5281/zenodo.556591 What’s new New fastjet algorithms have been contributed by Bastian Wieck (thanks!): EeGenKtAlgorithm EeKtAlgorithm fastjet is now also able to compute exclusive jets (thanks again Bastian Wieck) A new lcio package, with initial read/write support for (most) of the LCIO event data model, has been released: MCParticle SimTrackerHit SimCalorimeterHit LCFloatVec LCIntVec LCStrVec RawCalorimeterHit CalorimeterHit TrackerData TrackerHit TrackerHitPlane TrackerHitZCylinder TrackerPulse TrackerRawData Track Cluster Vertex ReconstructedParticle LCGenericObject LCRelation See the lcio-ls command and the examples for more informations.

Go HEP release 0.1


It’s with great pleasure that we can announce that the Go-HEP release v0.1 is out: Changelog: https://github.com/go-hep/hep/releases/v0.1 Sources (zip): https://github.com/go-hep/hep/archive/v0.1.zip Sources (tar): https://github.com/go-hep/hep/archive/v0.1.tar.gz What’s new What’s new? Well, lots of things since it is our very first release. But since the merge of the github.com/go-hep/xyz repositories into the mono-repository go-hep/hep and the introduction of the go-hep.org/x/hep/… vanity imports, quite a few things. First: as we have tagged a release, Go-HEP is now citable.