Pages in New

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 ( "" ) func foo() { f, err := rootio.Open("root://") if err != nil { … } defer f.Close() } all the root-xyz commands can now also leverage xrootd:

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 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.

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 ( 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 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 "{mat,stat,…}", instead of the old "{mat64,stat,…}" Go-HEP has also migrated all its use of gonum/plot from "…" to the new "…" 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 packages to their new location –, 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: Sources (zip): Sources (tar): DOI: rootio What is supported and tested so far (in no-split and full-split mode): // 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: Sources (zip): Sources (tar): DOI: 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: Sources (zip): Sources (tar): What’s new What’s new? Well, lots of things since it is our very first release. But since the merge of the repositories into the mono-repository go-hep/hep and the introduction of the… vanity imports, quite a few things. First: as we have tagged a release, Go-HEP is now citable.